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|/$|| unless $path eq "/";           # 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(@m);
 919
 920     push(@m,"
 921 dynamic :: $self->{BASEEXT}.exp
 922
 923 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
 924
 925     push(@m,"
 926 static :: $self->{BASEEXT}.exp
 927
 928 ") unless $self->{SKIPHASH}{'static'};  # we avoid a warning if we tick them
 929
 930     push(@m,"
 931 $self->{BASEEXT}.exp: Makefile.PL
 932 ",'     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
 933         Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
 934         neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
 935 ');
 936
 937     join('',@m);
 938 }
 939
 940 =item dynamic (o)
 941
 942 Defines the dynamic target.
 943
 944 =cut
 945
 946 sub dynamic {
 947 # --- Dynamic Loading Sections ---
 948
 949     my($self) = shift;
 950     '
 951 ## $(INST_PM) has been moved to the all: target.
 952 ## It remains here for awhile to allow for old usage: "make dynamic"
 953 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
 954 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
 955         '.$self->{NOECHO}.'$(NOOP)
 956 ';
 957 }
 958
 959 =item dynamic_bs (o)
 960
 961 Defines targets for bootstrap files.
 962
 963 =cut
 964
 965 sub dynamic_bs {
 966     my($self, %attribs) = @_;
 967     return '
 968 BOOTSTRAP =
 969 ' unless $self->has_link_code();
 970
 971     return '
 972 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
 973
 974 # As Mkbootstrap might not write a file (if none is required)
 975 # we use touch to prevent make continually trying to remake it.
 976 # The DynaLoader only reads a non-empty file.
 977 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
 978         '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
 979         '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
 980                 -MExtUtils::Mkbootstrap \
 981                 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
 982         '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
 983         $(CHMOD) $(PERM_RW) $@
 984
 985 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
 986         '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
 987         -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
 988         $(CHMOD) $(PERM_RW) $@
 989 ';
 990 }
 991
 992 =item dynamic_lib (o)
 993
 994 Defines how to produce the *.so (or equivalent) files.
 995
 996 =cut
 997
 998 sub dynamic_lib {
 999     my($self, %attribs) = @_;
1000     return '' unless $self->needs_linking(); #might be because of a subdir
1001
1002     return '' unless $self->has_link_code;
1003
1004     my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1005     my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1006     my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1007     my($ldfrom) = '$(LDFROM)';
1008     $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
1009     my(@m);
1010     push(@m,'
1011 # This section creates the dynamically loadable $(INST_DYNAMIC)
1012 # from $(OBJECT) and possibly $(MYEXTLIB).
1013 ARMAYBE = '.$armaybe.'
1014 OTHERLDFLAGS = '.$otherldflags.'
1015 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1016
1017 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
1018 ');
1019     if ($armaybe ne ':'){
1020         $ldfrom = 'tmp$(LIB_EXT)';
1021         push(@m,'       $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1022         push(@m,'       $(RANLIB) '."$ldfrom\n");
1023     }
1024     $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1025
1026     # Brain dead solaris linker does not use LD_RUN_PATH?
1027     # This fixes dynamic extensions which need shared libs
1028     my $ldrun = '';
1029     $ldrun = join ' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}
1030        if ($^O eq 'solaris');
1031
1032     # The IRIX linker also doesn't use LD_RUN_PATH
1033     $ldrun = qq{-rpath "$self->{LD_RUN_PATH}"}
1034         if ($^O eq 'irix' && $self->{LD_RUN_PATH});
1035
1036     push(@m,'   LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1037                 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)');
1038     push @m, '
1039         $(CHMOD) $(PERM_RWX) $@
1040 ';
1041
1042     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1043     join('',@m);
1044 }
1045
1046 =item exescan
1047
1048 Deprecated method. Use libscan instead.
1049
1050 =cut
1051
1052 sub exescan {
1053     my($self,$path) = @_;
1054     $path;
1055 }
1056
1057 =item extliblist
1058
1059 Called by init_others, and calls ext ExtUtils::Liblist. See
1060 L<ExtUtils::Liblist> for details.
1061
1062 =cut
1063
1064 sub extliblist {
1065     my($self,$libs) = @_;
1066     require ExtUtils::Liblist;
1067     $self->ext($libs, $Verbose);
1068 }
1069
1070 =item file_name_is_absolute
1071
1072 Takes as argument a path and returns true, if it is an absolute path.
1073
1074 =cut
1075
1076 sub file_name_is_absolute {
1077     my($self,$file) = @_;
1078     if ($Is_Dos){
1079         $file =~ m{^([a-z]:)?[\\/]}i ;
1080     }
1081     else {
1082         $file =~ m:^/: ;
1083     }
1084 }
1085
1086 =item find_perl
1087
1088 Finds the executables PERL and FULLPERL
1089
1090 =cut
1091
1092 sub find_perl {
1093     my($self, $ver, $names, $dirs, $trace) = @_;
1094     my($name, $dir);
1095     if ($trace >= 2){
1096         print "Looking for perl $ver by these names:
1097 @$names
1098 in these dirs:
1099 @$dirs
1100 ";
1101     }
1102     foreach $dir (@$dirs){
1103         next unless defined $dir; # $self->{PERL_SRC} may be undefined
1104         foreach $name (@$names){
1105             my ($abs, $val);
1106             if ($self->file_name_is_absolute($name)) { # /foo/bar
1107                 $abs = $name;
1108             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1109                 $abs = $self->catfile($dir, $name);
1110             } else { # foo/bar
1111                 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1112             }
1113             print "Checking $abs\n" if ($trace >= 2);
1114             next unless $self->maybe_command($abs);
1115             print "Executing $abs\n" if ($trace >= 2);
1116             $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1117             if ($val =~ /VER_OK/) {
1118                 print "Using PERL=$abs\n" if $trace;
1119                 return $abs;
1120             } elsif ($trace >= 2) {
1121                 print "Result: `$val'\n";
1122             }
1123         }
1124     }
1125     print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1126     0; # false and not empty
1127 }
1128
1129 =back
1130
1131 =head2 Methods to actually produce chunks of text for the Makefile
1132
1133 The methods here are called for each MakeMaker object in the order
1134 specified by @ExtUtils::MakeMaker::MM_Sections.
1135
1136 =over 2
1137
1138 =item fixin
1139
1140 Inserts the sharpbang or equivalent magic number to a script
1141
1142 =cut
1143
1144 sub fixin { # stolen from the pink Camel book, more or less
1145     my($self,@files) = @_;
1146     my($does_shbang) = $Config::Config{'sharpbang'} =~ /^\s*\#\!/;
1147     my($file,$interpreter);
1148     for $file (@files) {
1149         local(*FIXIN);
1150         local(*FIXOUT);
1151         open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1152         local $/ = "\n";
1153         chomp(my $line = <FIXIN>);
1154         next unless $line =~ s/^\s*\#!\s*//;     # Not a shbang file.
1155         # Now figure out the interpreter name.
1156         my($cmd,$arg) = split ' ', $line, 2;
1157         $cmd =~ s!^.*/!!;
1158
1159         # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1160         if ($cmd eq "perl") {
1161             if ($Config{startperl} =~ m,^\#!.*/perl,) {
1162                 $interpreter = $Config{startperl};
1163                 $interpreter =~ s,^\#!,,;
1164             } else {
1165                 $interpreter = $Config{perlpath};
1166             }
1167         } else {
1168             my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1169             $interpreter = '';
1170             my($dir);
1171             foreach $dir (@absdirs) {
1172                 if ($self->maybe_command($cmd)) {
1173                     warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1174                     $interpreter = $self->catfile($dir,$cmd);
1175                 }
1176             }
1177         }
1178         # Figure out how to invoke interpreter on this machine.
1179
1180         my($shb) = "";
1181         if ($interpreter) {
1182             print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1183             # this is probably value-free on DOSISH platforms
1184             if ($does_shbang) {
1185                 $shb .= "$Config{'sharpbang'}$interpreter";
1186                 $shb .= ' ' . $arg if defined $arg;
1187                 $shb .= "\n";
1188             }
1189             $shb .= qq{
1190 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1191     if 0; # not running under some shell
1192 } unless $Is_Win32; # this won't work on win32, so don't
1193         } else {
1194             warn "Can't find $cmd in PATH, $file unchanged"
1195                 if $Verbose;
1196             next;
1197         }
1198
1199         unless ( open(FIXOUT,">$file.new") ) {
1200             warn "Can't create new $file: $!\n";
1201             next;
1202         }
1203         my($dev,$ino,$mode) = stat FIXIN;
1204         # If they override perm_rwx, we won't notice it during fixin,
1205         # because fixin is run through a new instance of MakeMaker.
1206         # That is why we must run another CHMOD later.
1207         $mode = oct($self->perm_rwx) unless $dev;
1208         chmod $mode, $file;
1209
1210         # Print out the new #! line (or equivalent).
1211         local $\;
1212         undef $/;
1213         print FIXOUT $shb, <FIXIN>;
1214         close FIXIN;
1215         close FIXOUT;
1216         # can't rename open files on some DOSISH platforms
1217         unless ( rename($file, "$file.bak") ) {
1218             warn "Can't rename $file to $file.bak: $!";
1219             next;
1220         }
1221         unless ( rename("$file.new", $file) ) {
1222             warn "Can't rename $file.new to $file: $!";
1223             unless ( rename("$file.bak", $file) ) {
1224                 warn "Can't rename $file.bak back to $file either: $!";
1225                 warn "Leaving $file renamed as $file.bak\n";
1226             }
1227             next;
1228         }
1229         unlink "$file.bak";
1230     } continue {
1231         chmod oct($self->perm_rwx), $file or
1232           die "Can't reset permissions for $file: $!\n";
1233         system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1234     }
1235 }
1236
1237 =item force (o)
1238
1239 Just writes FORCE:
1240
1241 =cut
1242
1243 sub force {
1244     my($self) = shift;
1245     '# Phony target to force checking subdirectories.
1246 FORCE:
1247         '.$self->{NOECHO}.'$(NOOP)
1248 ';
1249 }
1250
1251 =item guess_name
1252
1253 Guess the name of this package by examining the working directory's
1254 name. MakeMaker calls this only if the developer has not supplied a
1255 NAME attribute.
1256
1257 =cut
1258
1259 # ';
1260
1261 sub guess_name {
1262     my($self) = @_;
1263     use Cwd 'cwd';
1264     my $name = basename(cwd());
1265     $name =~ s|[\-_][\d\.\-]+$||;   # this is new with MM 5.00, we
1266                                     # strip minus or underline
1267                                     # followed by a float or some such
1268     print "Warning: Guessing NAME [$name] from current directory name.\n";
1269     $name;
1270 }
1271
1272 =item has_link_code
1273
1274 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1275 object that need a compiler. Does not descend into subdirectories as
1276 needs_linking() does.
1277
1278 =cut
1279
1280 sub has_link_code {
1281     my($self) = shift;
1282     return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1283     if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1284         $self->{HAS_LINK_CODE} = 1;
1285         return 1;
1286     }
1287     return $self->{HAS_LINK_CODE} = 0;
1288 }
1289
1290 =item init_dirscan
1291
1292 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1293
1294 =cut
1295
1296 sub init_dirscan {      # --- File and Directory Lists (.xs .pm .pod etc)
1297     my($self) = @_;
1298     my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1299     local(%pm); #the sub in find() has to see this hash
1300     @ignore{qw(Makefile.PL test.pl)} = (1,1);
1301     $ignore{'makefile.pl'} = 1 if $Is_VMS;
1302     foreach $name ($self->lsdir($self->curdir)){
1303         next if $name =~ /\#/;
1304         next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1305         next unless $self->libscan($name);
1306         if (-d $name){
1307             next if -l $name; # We do not support symlinks at all
1308             $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1309         } elsif ($name =~ /\.xs$/){
1310             my($c); ($c = $name) =~ s/\.xs$/.c/;
1311             $xs{$name} = $c;
1312             $c{$c} = 1;
1313         } elsif ($name =~ /\.c(pp|xx|c)?$/i){  # .c .C .cpp .cxx .cc
1314             $c{$name} = 1
1315                 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1316         } elsif ($name =~ /\.h$/i){
1317             $h{$name} = 1;
1318         } elsif ($name =~ /\.PL$/) {
1319             ($pl_files{$name} = $name) =~ s/\.PL$// ;
1320         } elsif ($Is_VMS && $name =~ /\.pl$/) {  # case-insensitive filesystem
1321             local($/); open(PL,$name); my $txt = <PL>; close PL;
1322             if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1323                 ($pl_files{$name} = $name) =~ s/\.pl$// ;
1324             }
1325             else { $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name); }
1326         } elsif ($name =~ /\.(p[ml]|pod)$/){
1327             $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1328         }
1329     }
1330
1331     # Some larger extensions often wish to install a number of *.pm/pl
1332     # files into the library in various locations.
1333
1334     # The attribute PMLIBDIRS holds an array reference which lists
1335     # subdirectories which we should search for library files to
1336     # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
1337     # recursively search through the named directories (skipping any
1338     # which don't exist or contain Makefile.PL files).
1339
1340     # For each *.pm or *.pl file found $self->libscan() is called with
1341     # the default installation path in $_[1]. The return value of
1342     # libscan defines the actual installation location.  The default
1343     # libscan function simply returns the path.  The file is skipped
1344     # if libscan returns false.
1345
1346     # The default installation location passed to libscan in $_[1] is:
1347     #
1348     #  ./*.pm           => $(INST_LIBDIR)/*.pm
1349     #  ./xyz/...        => $(INST_LIBDIR)/xyz/...
1350     #  ./lib/...        => $(INST_LIB)/...
1351     #
1352     # In this way the 'lib' directory is seen as the root of the actual
1353     # perl library whereas the others are relative to INST_LIBDIR
1354     # (which includes PARENT_NAME). This is a subtle distinction but one
1355     # that's important for nested modules.
1356
1357     $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1358         unless $self->{PMLIBDIRS};
1359
1360     #only existing directories that aren't in $dir are allowed
1361
1362     # Avoid $_ wherever possible:
1363     # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1364     my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1365     my ($pmlibdir);
1366     @{$self->{PMLIBDIRS}} = ();
1367     foreach $pmlibdir (@pmlibdirs) {
1368         -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1369     }
1370
1371     if (@{$self->{PMLIBDIRS}}){
1372         print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1373             if ($Verbose >= 2);
1374         require File::Find;
1375         File::Find::find(sub {
1376             if (-d $_){
1377                 if ($_ eq "CVS" || $_ eq "RCS"){
1378                     $File::Find::prune = 1;
1379                 }
1380                 return;
1381             }
1382             return if /\#/;
1383             my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1384             my($striplibpath,$striplibname);
1385             $prefix =  '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1386             ($striplibname,$striplibpath) = fileparse($striplibpath);
1387             my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1388             local($_) = $inst; # for backwards compatibility
1389             $inst = $self->libscan($inst);
1390             print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1391             return unless $inst;
1392             $pm{$path} = $inst;
1393         }, @{$self->{PMLIBDIRS}});
1394     }
1395
1396     $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1397     $self->{XS}  = \%xs             unless $self->{XS};
1398     $self->{PM}  = \%pm             unless $self->{PM};
1399     $self->{C}   = [sort keys %c]   unless $self->{C};
1400     my(@o_files) = @{$self->{C}};
1401     $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
1402     $self->{H}   = [sort keys %h]   unless $self->{H};
1403     $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1404
1405     # Set up names of manual pages to generate from pods
1406     if ($self->{MAN1PODS}) {
1407     } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1408         $self->{MAN1PODS} = {};
1409     } else {
1410         my %manifypods = ();
1411         if ( exists $self->{EXE_FILES} ) {
1412             foreach $name (@{$self->{EXE_FILES}}) {
1413 #               use FileHandle ();
1414 #               my $fh = new FileHandle;
1415                 local *FH;
1416                 my($ispod)=0;
1417 #               if ($fh->open("<$name")) {
1418                 if (open(FH,"<$name")) {
1419 #                   while (<$fh>) {
1420                     while (<FH>) {
1421                         if (/^=head1\s+\w+/) {
1422                             $ispod=1;
1423                             last;
1424                         }
1425                     }
1426 #                   $fh->close;
1427                     close FH;
1428                 } else {
1429                     # If it doesn't exist yet, we assume, it has pods in it
1430                     $ispod = 1;
1431                 }
1432                 if( $ispod ) {
1433                     $manifypods{$name} =
1434                         $self->catfile('$(INST_MAN1DIR)',
1435                                        basename($name).'.$(MAN1EXT)');
1436                 }
1437             }
1438         }
1439         $self->{MAN1PODS} = \%manifypods;
1440     }
1441     if ($self->{MAN3PODS}) {
1442     } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1443         $self->{MAN3PODS} = {};
1444     } else {
1445         my %manifypods = (); # we collect the keys first, i.e. the files
1446                              # we have to convert to pod
1447         foreach $name (keys %{$self->{PM}}) {
1448             if ($name =~ /\.pod$/ ) {
1449                 $manifypods{$name} = $self->{PM}{$name};
1450             } elsif ($name =~ /\.p[ml]$/ ) {
1451 #               use FileHandle ();
1452 #               my $fh = new FileHandle;
1453                 local *FH;
1454                 my($ispod)=0;
1455 #               $fh->open("<$name");
1456                 if (open(FH,"<$name")) {
1457                     #           while (<$fh>) {
1458                     while (<FH>) {
1459                         if (/^=head1\s+\w+/) {
1460                             $ispod=1;
1461                             last;
1462                         }
1463                     }
1464                     #           $fh->close;
1465                     close FH;
1466                 } else {
1467                     $ispod = 1;
1468                 }
1469                 if( $ispod ) {
1470                     $manifypods{$name} = $self->{PM}{$name};
1471                 }
1472             }
1473         }
1474
1475         # Remove "Configure.pm" and similar, if it's not the only pod listed
1476         # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1477         foreach $name (keys %manifypods) {
1478             if ($name =~ /(config|setup).*\.pm/i) {
1479                 delete $manifypods{$name};
1480                 next;
1481             }
1482             my($manpagename) = $name;
1483             unless ($manpagename =~ s!^\W*lib\W+!!) { # everything below lib is ok
1484                 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1485             }
1486             $manpagename =~ s/\.p(od|m|l)$//;
1487             $manpagename = $self->replace_manpage_separator($manpagename);
1488             $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
1489         }
1490         $self->{MAN3PODS} = \%manifypods;
1491     }
1492 }
1493
1494 =item init_main
1495
1496 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1497 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1498 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1499 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1500
1501 =cut
1502
1503 sub init_main {
1504     my($self) = @_;
1505
1506     # --- Initialize Module Name and Paths
1507
1508     # NAME    = Foo::Bar::Oracle
1509     # FULLEXT = Foo/Bar/Oracle
1510     # BASEEXT = Oracle
1511     # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1512     # PARENT_NAME = Foo::Bar
1513 ### Only UNIX:
1514 ###    ($self->{FULLEXT} =
1515 ###     $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1516     $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1517
1518
1519     # Copied from DynaLoader:
1520
1521     my(@modparts) = split(/::/,$self->{NAME});
1522     my($modfname) = $modparts[-1];
1523
1524     # Some systems have restrictions on files names for DLL's etc.
1525     # mod2fname returns appropriate file base name (typically truncated)
1526     # It may also edit @modparts if required.
1527     if (defined &DynaLoader::mod2fname) {
1528         $modfname = &DynaLoader::mod2fname(\@modparts);
1529     }
1530
1531     ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)$! ;
1532
1533     if (defined &DynaLoader::mod2fname) {
1534         # As of 5.001m, dl_os2 appends '_'
1535         $self->{DLBASE} = $modfname;
1536     } else {
1537         $self->{DLBASE} = '$(BASEEXT)';
1538     }
1539
1540
1541     ### ROOTEXT deprecated from MM 5.32
1542 ###    ($self->{ROOTEXT} =
1543 ###     $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ;      #eg. /BSD/Foo
1544 ###    $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1545
1546
1547     # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1548
1549     # *Real* information: where did we get these two from? ...
1550     my $inc_config_dir = dirname($INC{'Config.pm'});
1551     my $inc_carp_dir   = dirname($INC{'Carp.pm'});
1552
1553     unless ($self->{PERL_SRC}){
1554         my($dir);
1555         foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir())){
1556             if (
1557                 -f $self->catfile($dir,"config.sh")
1558                 &&
1559                 -f $self->catfile($dir,"perl.h")
1560                 &&
1561                 -f $self->catfile($dir,"lib","Exporter.pm")
1562                ) {
1563                 $self->{PERL_SRC}=$dir ;
1564                 last;
1565             }
1566         }
1567     }
1568     if ($self->{PERL_SRC}){
1569         $self->{PERL_LIB}     ||= $self->catdir("$self->{PERL_SRC}","lib");
1570         $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1571         $self->{PERL_INC}     = ($Is_Win32) ? $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1572
1573         # catch a situation that has occurred a few times in the past:
1574         unless (
1575                 -s $self->catfile($self->{PERL_SRC},'cflags')
1576                 or
1577                 $Is_VMS
1578                 &&
1579                 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1580                 or
1581                 $Is_Mac
1582                 or
1583                 $Is_Win32
1584                ){
1585             warn qq{
1586 You cannot build extensions below the perl source tree after executing
1587 a 'make clean' in the perl source tree.
1588
1589 To rebuild extensions distributed with the perl source you should
1590 simply Configure (to include those extensions) and then build perl as
1591 normal. After installing perl the source tree can be deleted. It is
1592 not needed for building extensions by running 'perl Makefile.PL'
1593 usually without extra arguments.
1594
1595 It is recommended that you unpack and build additional extensions away
1596 from the perl source tree.
1597 };
1598         }
1599     } else {
1600         # we should also consider $ENV{PERL5LIB} here
1601         $self->{PERL_LIB}     ||= $Config::Config{privlibexp};
1602         $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1603         $self->{PERL_INC}     = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1604         my $perl_h;
1605         unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1606             die qq{
1607 Error: Unable to locate installed Perl libraries or Perl source code.
1608
1609 It is recommended that you install perl in a standard location before
1610 building extensions. Some precompiled versions of perl do not contain
1611 these header files, so you cannot build extensions. In such a case,
1612 please build and install your perl from a fresh perl distribution. It
1613 usually solves this kind of problem.
1614
1615 \(You get this message, because MakeMaker could not find "$perl_h"\)
1616 };
1617         }
1618 #        print STDOUT "Using header files found in $self->{PERL_INC}\n"
1619 #            if $Verbose && $self->needs_linking();
1620
1621     }
1622
1623     # We get SITELIBEXP and SITEARCHEXP directly via
1624     # Get_from_Config. When we are running standard modules, these
1625     # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1626     # set it to "site". I prefer that INSTALLDIRS be set from outside
1627     # MakeMaker.
1628     $self->{INSTALLDIRS} ||= "site";
1629
1630     # INST_LIB typically pre-set if building an extension after
1631     # perl has been built and installed. Setting INST_LIB allows
1632     # you to build directly into, say $Config::Config{privlibexp}.
1633     unless ($self->{INST_LIB}){
1634
1635
1636         ##### XXXXX We have to change this nonsense
1637
1638         if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1639             $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1640         } else {
1641             $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1642         }
1643     }
1644     $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1645     $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1646
1647     # We need to set up INST_LIBDIR before init_libscan() for VMS
1648     my @parentdir = split(/::/, $self->{PARENT_NAME});
1649     $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1650     $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1651     $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1652     $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1653
1654     # INST_EXE is deprecated, should go away March '97
1655     $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1656     $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1657
1658     # The user who requests an installation directory explicitly
1659     # should not have to tell us a architecture installation directory
1660     # as well. We look if a directory exists that is named after the
1661     # architecture. If not we take it as a sign that it should be the
1662     # same as the requested installation directory. Otherwise we take
1663     # the found one.
1664     # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1665     my($libpair);
1666     for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1667         my $lib = "install$libpair->{l}";
1668         my $Lib = uc $lib;
1669         my $Arch = uc "install$libpair->{a}";
1670         if( $self->{$Lib} && ! $self->{$Arch} ){
1671             my($ilib) = $Config{$lib};
1672             $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1673
1674             $self->prefixify($Arch,$ilib,$self->{$Lib});
1675
1676             unless (-d $self->{$Arch}) {
1677                 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1678                 $self->{$Arch} = $self->{$Lib};
1679             }
1680             print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1681         }
1682     }
1683
1684     # we have to look at the relation between $Config{prefix} and the
1685     # requested values. We're going to set the $Config{prefix} part of
1686     # all the installation path variables to literally $(PREFIX), so
1687     # the user can still say make PREFIX=foo
1688     my($configure_prefix) = $Config{'prefix'};
1689     $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1690     $self->{PREFIX} ||= $configure_prefix;
1691
1692
1693     my($install_variable,$search_prefix,$replace_prefix);
1694
1695     # The rule, taken from Configure, is that if prefix contains perl,
1696     # we shape the tree
1697     #    perlprefix/lib/                INSTALLPRIVLIB
1698     #    perlprefix/lib/pod/
1699     #    perlprefix/lib/site_perl/      INSTALLSITELIB
1700     #    perlprefix/bin/                INSTALLBIN
1701     #    perlprefix/man/                INSTALLMAN1DIR
1702     # else
1703     #    prefix/lib/perl5/              INSTALLPRIVLIB
1704     #    prefix/lib/perl5/pod/
1705     #    prefix/lib/perl5/site_perl/    INSTALLSITELIB
1706     #    prefix/bin/                    INSTALLBIN
1707     #    prefix/lib/perl5/man/          INSTALLMAN1DIR
1708
1709     $replace_prefix = qq[\$\(PREFIX\)];
1710     for $install_variable (qw/
1711                            INSTALLBIN
1712                            INSTALLSCRIPT
1713                            /) {
1714         $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1715     }
1716     $search_prefix = $configure_prefix =~ /perl/ ?
1717         $self->catdir($configure_prefix,"lib") :
1718         $self->catdir($configure_prefix,"lib","perl5");
1719     if ($self->{LIB}) {
1720         $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1721         $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1722             $self->catdir($self->{LIB},$Config{'archname'});
1723     } else {
1724         $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1725             $self->catdir(qq[\$\(PREFIX\)],"lib") :
1726                 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5");
1727         for $install_variable (qw/
1728                                INSTALLPRIVLIB
1729                                INSTALLARCHLIB
1730                                INSTALLSITELIB
1731                                INSTALLSITEARCH
1732                                /) {
1733             $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1734         }
1735     }
1736     $search_prefix = $configure_prefix =~ /perl/ ?
1737         $self->catdir($configure_prefix,"man") :
1738             $self->catdir($configure_prefix,"lib","perl5","man");
1739     $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1740         $self->catdir(qq[\$\(PREFIX\)],"man") :
1741             $self->catdir(qq[\$\(PREFIX\)],"lib","perl5","man");
1742     for $install_variable (qw/
1743                            INSTALLMAN1DIR
1744                            INSTALLMAN3DIR
1745                            /) {
1746         $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1747     }
1748
1749     # Now we head at the manpages. Maybe they DO NOT want manpages
1750     # installed
1751     $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1752         unless defined $self->{INSTALLMAN1DIR};
1753     unless (defined $self->{INST_MAN1DIR}){
1754         if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1755             $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1756         } else {
1757             $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1758         }
1759     }
1760     $self->{MAN1EXT} ||= $Config::Config{man1ext};
1761
1762     $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1763         unless defined $self->{INSTALLMAN3DIR};
1764     unless (defined $self->{INST_MAN3DIR}){
1765         if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1766             $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1767         } else {
1768             $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1769         }
1770     }
1771     $self->{MAN3EXT} ||= $Config::Config{man3ext};
1772
1773
1774     # Get some stuff out of %Config if we haven't yet done so
1775     print STDOUT "CONFIG must be an array ref\n"
1776         if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1777     $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1778     push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1779     push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1780     my(%once_only,$m);
1781     foreach $m (@{$self->{CONFIG}}){
1782         next if $once_only{$m};
1783         print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1784                 unless exists $Config::Config{$m};
1785         $self->{uc $m} ||= $Config::Config{$m};
1786         $once_only{$m} = 1;
1787     }
1788
1789 # This is too dangerous:
1790 #    if ($^O eq "next") {
1791 #       $self->{AR} = "libtool";
1792 #       $self->{AR_STATIC_ARGS} = "-o";
1793 #    }
1794 # But I leave it as a placeholder
1795
1796     $self->{AR_STATIC_ARGS} ||= "cr";
1797
1798     # These should never be needed
1799     $self->{LD} ||= 'ld';
1800     $self->{OBJ_EXT} ||= '.o';
1801     $self->{LIB_EXT} ||= '.a';
1802
1803     $self->{MAP_TARGET} ||= "perl";
1804
1805     $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1806
1807     # make a simple check if we find Exporter
1808     warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1809         (Exporter.pm not found)"
1810         unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1811         $self->{NAME} eq "ExtUtils::MakeMaker";
1812
1813     # Determine VERSION and VERSION_FROM
1814     ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1815     if ($self->{VERSION_FROM}){
1816         $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1817             Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1818     }
1819
1820     # strip blanks
1821     if ($self->{VERSION}) {
1822         $self->{VERSION} =~ s/^\s+//;
1823         $self->{VERSION} =~ s/\s+$//;
1824     }
1825
1826     $self->{VERSION} ||= "0.10";
1827     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1828
1829
1830     # Graham Barr and Paul Marquess had some ideas how to ensure
1831     # version compatibility between the *.pm file and the
1832     # corresponding *.xs file. The bottomline was, that we need an
1833     # XS_VERSION macro that defaults to VERSION:
1834     $self->{XS_VERSION} ||= $self->{VERSION};
1835
1836     # --- Initialize Perl Binary Locations
1837
1838     # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1839     # will be working versions of perl 5. miniperl has priority over perl
1840     # for PERL to ensure that $(PERL) is usable while building ./ext/*
1841     my ($component,@defpath);
1842     foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1843         push @defpath, $component if defined $component;
1844     }
1845     $self->{PERL} ||=
1846         $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1847             \@defpath, $Verbose );
1848     # don't check if perl is executable, maybe they have decided to
1849     # supply switches with perl
1850
1851     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1852     ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1853         unless ($self->{FULLPERL});
1854 }
1855
1856 =item init_others
1857
1858 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1859 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1860 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1861
1862 =cut
1863
1864 sub init_others {       # --- Initialize Other Attributes
1865     my($self) = shift;
1866
1867     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1868     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1869     # undefined. In any case we turn it into an anon array:
1870
1871     # May check $Config{libs} too, thus not empty.
1872     $self->{LIBS}=[''] unless $self->{LIBS};
1873
1874     $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1875     $self->{LD_RUN_PATH} = "";
1876     my($libs);
1877     foreach $libs ( @{$self->{LIBS}} ){
1878         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1879         my(@libs) = $self->extliblist($libs);
1880         if ($libs[0] or $libs[1] or $libs[2]){
1881             # LD_RUN_PATH now computed by ExtUtils::Liblist
1882             ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1883             last;
1884         }
1885     }
1886
1887     if ( $self->{OBJECT} ) {
1888         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1889     } else {
1890         # init_dirscan should have found out, if we have C files
1891         $self->{OBJECT} = "";
1892         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1893     }
1894     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1895     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1896     $self->{PERLMAINCC} ||= '$(CC)';
1897     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1898
1899     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1900     # the 'dynamic' section of MM.  We don't have this problem with
1901     # 'static', since we either must use it (%Config says we can't
1902     # use dynamic loading) or the caller asked for it explicitly.
1903     if (!$self->{LINKTYPE}) {
1904        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1905                         ? 'static'
1906                         : ($Config::Config{usedl} ? 'dynamic' : 'static');
1907     };
1908
1909     # These get overridden for VMS and maybe some other systems
1910     $self->{NOOP}  ||= '$(SHELL) -c true';
1911     $self->{FIRST_MAKEFILE} ||= "Makefile";
1912     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1913     $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1914     $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1915     $self->{RM_F}  ||= "rm -f";
1916     $self->{RM_RF} ||= "rm -rf";
1917     $self->{TOUCH} ||= "touch";
1918     $self->{TEST_F} ||= "test -f";
1919     $self->{CP} ||= "cp";
1920     $self->{MV} ||= "mv";
1921     $self->{CHMOD} ||= "chmod";
1922     $self->{UMASK_NULL} ||= "umask 0";
1923     $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1924 }
1925
1926 =item install (o)
1927
1928 Defines the install target.
1929
1930 =cut
1931
1932 sub install {
1933     my($self, %attribs) = @_;
1934     my(@m);
1935
1936     push @m, q{
1937 install :: all pure_install doc_install
1938
1939 install_perl :: all pure_perl_install doc_perl_install
1940
1941 install_site :: all pure_site_install doc_site_install
1942
1943 install_ :: install_site
1944         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1945
1946 pure_install :: pure_$(INSTALLDIRS)_install
1947
1948 doc_install :: doc_$(INSTALLDIRS)_install
1949         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
1950
1951 pure__install : pure_site_install
1952         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1953
1954 doc__install : doc_site_install
1955         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1956
1957 pure_perl_install ::
1958         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1959                 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1960                 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1961                 $(INST_LIB) $(INSTALLPRIVLIB) \
1962                 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
1963                 $(INST_BIN) $(INSTALLBIN) \
1964                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1965                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1966                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1967         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1968                 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
1969
1970
1971 pure_site_install ::
1972         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1973                 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
1974                 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
1975                 $(INST_LIB) $(INSTALLSITELIB) \
1976                 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
1977                 $(INST_BIN) $(INSTALLBIN) \
1978                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1979                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1980                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1981         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1982                 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
1983
1984 doc_perl_install ::
1985         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
1986                 "Module" "$(NAME)" \
1987                 "installed into" "$(INSTALLPRIVLIB)" \
1988                 LINKTYPE "$(LINKTYPE)" \
1989                 VERSION "$(VERSION)" \
1990                 EXE_FILES "$(EXE_FILES)" \
1991                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1992
1993 doc_site_install ::
1994         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
1995                 "Module" "$(NAME)" \
1996                 "installed into" "$(INSTALLSITELIB)" \
1997                 LINKTYPE "$(LINKTYPE)" \
1998                 VERSION "$(VERSION)" \
1999                 EXE_FILES "$(EXE_FILES)" \
2000                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2001
2002 };
2003
2004     push @m, q{
2005 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2006
2007 uninstall_from_perldirs ::
2008         }.$self->{NOECHO}.
2009         q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2010
2011 uninstall_from_sitedirs ::
2012         }.$self->{NOECHO}.
2013         q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2014 };
2015
2016     join("",@m);
2017 }
2018
2019 =item installbin (o)
2020
2021 Defines targets to install EXE_FILES.
2022
2023 =cut
2024
2025 sub installbin {
2026     my($self) = shift;
2027     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2028     return "" unless @{$self->{EXE_FILES}};
2029     my(@m, $from, $to, %fromto, @to);
2030     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2031     for $from (@{$self->{EXE_FILES}}) {
2032         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2033         local($_) = $path; # for backwards compatibility
2034         $to = $self->libscan($path);
2035         print "libscan($from) => '$to'\n" if ($Verbose >=2);
2036         $fromto{$from}=$to;
2037     }
2038     @to   = values %fromto;
2039     push(@m, qq{
2040 EXE_FILES = @{$self->{EXE_FILES}}
2041
2042 } . ($Is_Win32
2043   ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2044     -e "system qq[pl2bat.bat ].shift"
2045 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2046     -e "MY->fixin(shift)"
2047 }).qq{
2048 all :: @to
2049         $self->{NOECHO}\$(NOOP)
2050
2051 realclean ::
2052         $self->{RM_F} @to
2053 });
2054
2055     while (($from,$to) = each %fromto) {
2056         last unless defined $from;
2057         my $todir = dirname($to);
2058         push @m, "
2059 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2060         $self->{NOECHO}$self->{RM_F} $to
2061         $self->{CP} $from $to
2062         \$(FIXIN) $to
2063         -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2064 ";
2065     }
2066     join "", @m;
2067 }
2068
2069 =item libscan (o)
2070
2071 Takes a path to a file that is found by init_dirscan and returns false
2072 if we don't want to include this file in the library. Mainly used to
2073 exclude RCS, CVS, and SCCS directories from installation.
2074
2075 =cut
2076
2077 # ';
2078
2079 sub libscan {
2080     my($self,$path) = @_;
2081     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2082     $path;
2083 }
2084
2085 =item linkext (o)
2086
2087 Defines the linkext target which in turn defines the LINKTYPE.
2088
2089 =cut
2090
2091 sub linkext {
2092     my($self, %attribs) = @_;
2093     # LINKTYPE => static or dynamic or ''
2094     my($linktype) = defined $attribs{LINKTYPE} ?
2095       $attribs{LINKTYPE} : '$(LINKTYPE)';
2096     "
2097 linkext :: $linktype
2098         $self->{NOECHO}\$(NOOP)
2099 ";
2100 }
2101
2102 =item lsdir
2103
2104 Takes as arguments a directory name and a regular expression. Returns
2105 all entries in the directory that match the regular expression.
2106
2107 =cut
2108
2109 sub lsdir {
2110     my($self) = shift;
2111     my($dir, $regex) = @_;
2112     my(@ls);
2113     my $dh = new DirHandle;
2114     $dh->open($dir || ".") or return ();
2115     @ls = $dh->read;
2116     $dh->close;
2117     @ls = grep(/$regex/, @ls) if $regex;
2118     @ls;
2119 }
2120
2121 =item macro (o)
2122
2123 Simple subroutine to insert the macros defined by the macro attribute
2124 into the Makefile.
2125
2126 =cut
2127
2128 sub macro {
2129     my($self,%attribs) = @_;
2130     my(@m,$key,$val);
2131     while (($key,$val) = each %attribs){
2132         last unless defined $key;
2133         push @m, "$key = $val\n";
2134     }
2135     join "", @m;
2136 }
2137
2138 =item makeaperl (o)
2139
2140 Called by staticmake. Defines how to write the Makefile to produce a
2141 static new perl.
2142
2143 By default the Makefile produced includes all the static extensions in
2144 the perl library. (Purified versions of library files, e.g.,
2145 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2146
2147 =cut
2148
2149 sub makeaperl {
2150     my($self, %attribs) = @_;
2151     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2152         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2153     my(@m);
2154     push @m, "
2155 # --- MakeMaker makeaperl section ---
2156 MAP_TARGET    = $target
2157 FULLPERL      = $self->{FULLPERL}
2158 ";
2159     return join '', @m if $self->{PARENT};
2160
2161     my($dir) = join ":", @{$self->{DIR}};
2162
2163     unless ($self->{MAKEAPERL}) {
2164         push @m, q{
2165 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2166         $(MAKE) -f $(MAKE_APERL_FILE) $@
2167
2168 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2169         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2170         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2171                 Makefile.PL DIR=}, $dir, q{ \
2172                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2173                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2174
2175         foreach (@ARGV){
2176                 if( /\s/ ){
2177                         s/=(.*)/='$1'/;
2178                 }
2179                 push @m, " \\\n\t\t$_";
2180         }
2181 #       push @m, map( " \\\n\t\t$_", @ARGV );
2182         push @m, "\n";
2183
2184         return join '', @m;
2185     }
2186
2187
2188
2189     my($cccmd, $linkcmd, $lperl);
2190
2191
2192     $cccmd = $self->const_cccmd($libperl);
2193     $cccmd =~ s/^CCCMD\s*=\s*//;
2194     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2195     $cccmd .= " $Config::Config{cccdlflags}"
2196         if ($Config::Config{useshrplib} eq 'true');
2197     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2198
2199     # The front matter of the linkcommand...
2200     $linkcmd = join ' ', "\$(CC)",
2201             grep($_, @Config{qw(large split ldflags ccdlflags)});
2202     $linkcmd =~ s/\s+/ /g;
2203     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2204
2205     # Which *.a files could we make use of...
2206     local(%static);
2207     require File::Find;
2208     File::Find::find(sub {
2209         return unless m/\Q$self->{LIB_EXT}\E$/;
2210         return if m/^libperl/;
2211         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2212         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2213
2214         if( exists $self->{INCLUDE_EXT} ){
2215                 my $found = 0;
2216                 my $incl;
2217                 my $xx;
2218
2219                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2220                 $xx =~ s,/?$_,,;
2221                 $xx =~ s,/,::,g;
2222
2223                 # Throw away anything not explicitly marked for inclusion.
2224                 # DynaLoader is implied.
2225                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2226                         if( $xx eq $incl ){
2227                                 $found++;
2228                                 last;
2229                         }
2230                 }
2231                 return unless $found;
2232         }
2233         elsif( exists $self->{EXCLUDE_EXT} ){
2234                 my $excl;
2235                 my $xx;
2236
2237                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2238                 $xx =~ s,/?$_,,;
2239                 $xx =~ s,/,::,g;
2240
2241                 # Throw away anything explicitly marked for exclusion
2242                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2243                         return if( $xx eq $excl );
2244                 }
2245         }
2246
2247         # don't include the installed version of this extension. I
2248         # leave this line here, although it is not necessary anymore:
2249         # I patched minimod.PL instead, so that Miniperl.pm won't
2250         # enclude duplicates
2251
2252         # Once the patch to minimod.PL is in the distribution, I can
2253         # drop it
2254         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2255         use Cwd 'cwd';
2256         $static{cwd() . "/" . $_}++;
2257     }, grep( -d $_, @{$searchdirs || []}) );
2258
2259     # We trust that what has been handed in as argument, will be buildable
2260     $static = [] unless $static;
2261     @static{@{$static}} = (1) x @{$static};
2262
2263     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2264     for (sort keys %static) {
2265         next unless /\Q$self->{LIB_EXT}\E$/;
2266         $_ = dirname($_) . "/extralibs.ld";
2267         push @$extra, $_;
2268     }
2269
2270     grep(s/^/-I/, @{$perlinc || []});
2271
2272     $target = "perl" unless $target;
2273     $tmp = "." unless $tmp;
2274
2275 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2276 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2277 # extralibs.all are computed correctly
2278     push @m, "
2279 MAP_LINKCMD   = $linkcmd
2280 MAP_PERLINC   = @{$perlinc || []}
2281 MAP_STATIC    = ",
2282 join(" \\\n\t", reverse sort keys %static), "
2283
2284 MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
2285 ";
2286
2287     if (defined $libperl) {
2288         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2289     }
2290     unless ($libperl && -f $lperl) { # Ilya's code...
2291         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2292         $libperl ||= "libperl$self->{LIB_EXT}";
2293         $libperl   = "$dir/$libperl";
2294         $lperl   ||= "libperl$self->{LIB_EXT}";
2295         $lperl     = "$dir/$lperl";
2296
2297         if (! -f $libperl and ! -f $lperl) {
2298           # We did not find a static libperl. Maybe there is a shared one?
2299           if ($^O eq 'solaris' or $^O eq 'sunos') {
2300             $lperl  = $libperl = "$dir/$Config::Config{libperl}";
2301             # SUNOS ld does not take the full path to a shared library
2302             $libperl = '' if $^O eq 'sunos';
2303           }
2304         }
2305
2306         print STDOUT "Warning: $libperl not found
2307     If you're going to build a static perl binary, make sure perl is installed
2308     otherwise ignore this warning\n"
2309                 unless (-f $lperl || defined($self->{PERL_SRC}));
2310     }
2311
2312     push @m, "
2313 MAP_LIBPERL = $libperl
2314 ";
2315
2316     push @m, "
2317 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2318         $self->{NOECHO}$self->{RM_F} \$\@
2319         $self->{NOECHO}\$(TOUCH) \$\@
2320 ";
2321
2322     my $catfile;
2323     foreach $catfile (@$extra){
2324         push @m, "\tcat $catfile >> \$\@\n";
2325     }
2326     # SUNOS ld does not take the full path to a shared library
2327     my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2328
2329     # Brain dead solaris linker does not use LD_RUN_PATH?
2330     # This fixes dynamic extensions which need shared libs
2331     my $ldfrom = ($^O eq 'solaris')?
2332            join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2333
2334 push @m, "
2335 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2336         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom \$(MAP_STATIC) $llibperl `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2337         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2338         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2339         $self->{NOECHO}echo 'To remove the intermediate files say'
2340         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2341
2342 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2343 ";
2344     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2345
2346     push @m, qq{
2347 $tmp/perlmain.c: $makefilename}, q{
2348         }.$self->{NOECHO}.q{echo Writing $@
2349         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2350                 -e "writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)" > $@t && $(MV) $@t $@
2351
2352 };
2353     push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2354 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2355
2356
2357     push @m, q{
2358 doc_inst_perl:
2359         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2360         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2361                 "Perl binary" "$(MAP_TARGET)" \
2362                 MAP_STATIC "$(MAP_STATIC)" \
2363                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2364                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2365                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2366
2367 };
2368
2369     push @m, q{
2370 inst_perl: pure_inst_perl doc_inst_perl
2371
2372 pure_inst_perl: $(MAP_TARGET)
2373         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2374
2375 clean :: map_clean
2376
2377 map_clean :
2378         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2379 };
2380
2381     join '', @m;
2382 }
2383
2384 =item makefile (o)
2385
2386 Defines how to rewrite the Makefile.
2387
2388 =cut
2389
2390 sub makefile {
2391     my($self) = shift;
2392     my @m;
2393     # We do not know what target was originally specified so we
2394     # must force a manual rerun to be sure. But as it should only
2395     # happen very rarely it is not a significant problem.
2396     push @m, '
2397 $(OBJECT) : $(FIRST_MAKEFILE)
2398 ' if $self->{OBJECT};
2399
2400     push @m, q{
2401 # We take a very conservative approach here, but it\'s worth it.
2402 # We move Makefile to Makefile.old here to avoid gnu make looping.
2403 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2404         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2405         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2406         -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2407         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2408         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2409         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2410         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2411         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2412         false
2413
2414 # To change behavior to :: would be nice, but would break Tk b9.02
2415 # so you find such a warning below the dist target.
2416 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2417 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2418 };
2419
2420     join "", @m;
2421 }
2422
2423 =item manifypods (o)
2424
2425 Defines targets and routines to translate the pods into manpages and
2426 put them into the INST_* directories.
2427
2428 =cut
2429
2430 sub manifypods {
2431     my($self, %attribs) = @_;
2432     return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2433         %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2434     my($dist);
2435     my($pod2man_exe);
2436     if (defined $self->{PERL_SRC}) {
2437         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2438     } else {
2439         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2440     }
2441     unless ($self->perl_script($pod2man_exe)) {
2442         # No pod2man but some MAN3PODS to be installed
2443         print <<END;
2444
2445 Warning: I could not locate your pod2man program. Please make sure,
2446          your pod2man program is in your PATH before you execute 'make'
2447
2448 END
2449         $pod2man_exe = "-S pod2man";
2450     }
2451     my(@m);
2452     push @m,
2453 qq[POD2MAN_EXE = $pod2man_exe\n],
2454 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2455 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2456  $self->{MAKEFILE}, q[";' \\
2457 -e 'print "Manifying $$m{$$_}\n";' \\
2458 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2459 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2460 ];
2461     push @m, "\nmanifypods : pure_all ";
2462     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2463
2464     push(@m,"\n");
2465     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2466         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2467         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2468     }
2469     join('', @m);
2470 }
2471
2472 =item maybe_command
2473
2474 Returns true, if the argument is likely to be a command.
2475
2476 =cut
2477
2478 sub maybe_command {
2479     my($self,$file) = @_;
2480     return $file if -x $file && ! -d $file;
2481     return;
2482 }
2483
2484 =item maybe_command_in_dirs
2485
2486 method under development. Not yet used. Ask Ilya :-)
2487
2488 =cut
2489
2490 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2491 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2492     my($self, $names, $dirs, $trace, $ver) = @_;
2493     my($name, $dir);
2494     foreach $dir (@$dirs){
2495         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2496         foreach $name (@$names){
2497             my($abs,$tryabs);
2498             if ($self->file_name_is_absolute($name)) { # /foo/bar
2499                 $abs = $name;
2500             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2501                 $abs = $self->catfile($dir, $name);
2502             } else { # foo/bar
2503                 $abs = $self->catfile($self->curdir, $name);
2504             }
2505             print "Checking $abs for $name\n" if ($trace >= 2);
2506             next unless $tryabs = $self->maybe_command($abs);
2507             print "Substituting $tryabs instead of $abs\n"
2508                 if ($trace >= 2 and $tryabs ne $abs);
2509             $abs = $tryabs;
2510             if (defined $ver) {
2511                 print "Executing $abs\n" if ($trace >= 2);
2512                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2513                     print "Using PERL=$abs\n" if $trace;
2514                     return $abs;
2515                 }
2516             } else { # Do not look for perl
2517                 return $abs;
2518             }
2519         }
2520     }
2521 }
2522
2523 =item needs_linking (o)
2524
2525 Does this module need linking? Looks into subdirectory objects (see
2526 also has_link_code())
2527
2528 =cut
2529
2530 sub needs_linking {
2531     my($self) = shift;
2532     my($child,$caller);
2533     $caller = (caller(0))[3];
2534     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2535     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2536     if ($self->has_link_code or $self->{MAKEAPERL}){
2537         $self->{NEEDS_LINKING} = 1;
2538         return 1;
2539     }
2540     foreach $child (keys %{$self->{CHILDREN}}) {
2541         if ($self->{CHILDREN}->{$child}->needs_linking) {
2542             $self->{NEEDS_LINKING} = 1;
2543             return 1;
2544         }
2545     }
2546     return $self->{NEEDS_LINKING} = 0;
2547 }
2548
2549 =item nicetext
2550
2551 misnamed method (will have to be changed). The MM_Unix method just
2552 returns the argument without further processing.
2553
2554 On VMS used to insure that colons marking targets are preceded by
2555 space - most Unix Makes don't need this, but it's necessary under VMS
2556 to distinguish the target delimiter from a colon appearing as part of
2557 a filespec.
2558
2559 =cut
2560
2561 sub nicetext {
2562     my($self,$text) = @_;
2563     $text;
2564 }
2565
2566 =item parse_version
2567
2568 parse a file and return what you think is $VERSION in this file set to
2569
2570 =cut
2571
2572 sub parse_version {
2573     my($self,$parsefile) = @_;
2574     my $result;
2575     local *FH;
2576     local $/ = "\n";
2577     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2578     my $inpod = 0;
2579     while (<FH>) {
2580         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2581         next if $inpod;
2582         chop;
2583         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2584         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2585         my $eval = qq{
2586             package ExtUtils::MakeMaker::_version;
2587             no strict;
2588
2589             local $1$2;
2590             \$$2=undef; do {
2591                 $_
2592             }; \$$2
2593         };
2594         local($^W) = 0;
2595         $result = eval($eval);
2596         die "Could not eval '$eval' in $parsefile: $@" if $@;
2597         $result = "undef" unless defined $result;
2598         last;
2599     }
2600     close FH;
2601     return $result;
2602 }
2603
2604 =item parse_abstract
2605
2606 parse a file and return what you think is the ABSTRACT
2607
2608 =cut
2609
2610 sub parse_abstract {
2611     my($self,$parsefile) = @_;
2612     my $result;
2613     local *FH;
2614     local $/ = "\n";
2615     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2616     my $inpod = 0;
2617     my $package = $self->{DISTNAME};
2618     $package =~ s/-/::/;
2619     while (<FH>) {
2620         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2621         next if !$inpod;
2622         chop;
2623         next unless /^($package\s-\s)(.*)/;
2624         $result = $2;
2625         last;
2626     }
2627     close FH;
2628     return $result;
2629 }
2630
2631 =item pasthru (o)
2632
2633 Defines the string that is passed to recursive make calls in
2634 subdirectories.
2635
2636 =cut
2637
2638 sub pasthru {
2639     my($self) = shift;
2640     my(@m,$key);
2641
2642     my(@pasthru);
2643     my($sep) = $Is_VMS ? ',' : '';
2644     $sep .= "\\\n\t";
2645
2646     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2647         push @pasthru, "$key=\"\$($key)\"";
2648     }
2649
2650     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2651     join "", @m;
2652 }
2653
2654 =item path
2655
2656 Takes no argument, returns the environment variable PATH as an array.
2657
2658 =cut
2659
2660 sub path {
2661     my($self) = @_;
2662     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2663     my $path = $ENV{PATH};
2664     $path =~ s:\\:/:g if $Is_OS2;
2665     my @path = split $path_sep, $path;
2666     foreach(@path) { $_ = '.' if $_ eq '' }
2667     @path;
2668 }
2669
2670 =item perl_script
2671
2672 Takes one argument, a file name, and returns the file name, if the
2673 argument is likely to be a perl script. On MM_Unix this is true for
2674 any ordinary, readable file.
2675
2676 =cut
2677
2678 sub perl_script {
2679     my($self,$file) = @_;
2680     return $file if -r $file && -f _;
2681     return;
2682 }
2683
2684 =item perldepend (o)
2685
2686 Defines the dependency from all *.h files that come with the perl
2687 distribution.
2688
2689 =cut
2690
2691 sub perldepend {
2692     my($self) = shift;
2693     my(@m);
2694     push @m, q{
2695 # Check for unpropogated config.sh changes. Should never happen.
2696 # We do NOT just update config.h because that is not sufficient.
2697 # An out of date config.h is not fatal but complains loudly!
2698 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2699         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2700
2701 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2702         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2703         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2704 } if $self->{PERL_SRC};
2705
2706     return join "", @m unless $self->needs_linking;
2707
2708     push @m, q{
2709 PERL_HDRS = \
2710 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2711 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2712 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2713 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2714 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2715 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2716 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2717 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2718 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h         $(PERL_INC)/iperlsys.h \
2719 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2720
2721 $(OBJECT) : $(PERL_HDRS)
2722 } if $self->{OBJECT};
2723
2724     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2725
2726     join "\n", @m;
2727 }
2728
2729 =item ppd
2730
2731 Defines target that creates a PPD (Perl Package Description) file
2732 for a binary distribution.
2733
2734 =cut
2735
2736 sub ppd {
2737     my($self) = @_;
2738     my(@m);
2739     if ($self->{ABSTRACT_FROM}){
2740         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2741             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2742     }
2743     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2744     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2745     push(@m, "ppd:\n");
2746     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2747     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2748     my $abstract = $self->{ABSTRACT};
2749     $abstract =~ s/</&lt;/g;
2750     $abstract =~ s/>/&gt;/g;
2751     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2752     my ($author) = $self->{AUTHOR};
2753     $author =~ s/@/\\@/g;
2754     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2755     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2756     my ($prereq);
2757     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2758         my $pre_req = $prereq;
2759         $pre_req =~ s/::/-/g;
2760         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" />\\n}");
2761     }
2762     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
2763     my ($bin_location) = $self->{BINARY_LOCATION};
2764     $bin_location =~ s/\\/\\\\/g;
2765     if ($self->{PPM_INSTALL_SCRIPT}) {
2766         if ($self->{PPM_INSTALL_EXEC}) {
2767             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2768         }
2769         else {
2770             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2771         }
2772     }
2773     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
2774     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
2775     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
2776
2777     join("", @m);
2778 }
2779
2780 =item perm_rw (o)
2781
2782 Returns the attribute C<PERM_RW> or the string C<644>.
2783 Used as the string that is passed
2784 to the C<chmod> command to set the permissions for read/writeable files.
2785 MakeMaker chooses C<644> because it has turned out in the past that
2786 relying on the umask provokes hard-to-track bugreports.
2787 When the return value is used by the perl function C<chmod>, it is
2788 interpreted as an octal value.
2789
2790 =cut
2791
2792 sub perm_rw {
2793     shift->{PERM_RW} || "644";
2794 }
2795
2796 =item perm_rwx (o)
2797
2798 Returns the attribute C<PERM_RWX> or the string C<755>,
2799 i.e. the string that is passed
2800 to the C<chmod> command to set the permissions for executable files.
2801 See also perl_rw.
2802
2803 =cut
2804
2805 sub perm_rwx {
2806     shift->{PERM_RWX} || "755";
2807 }
2808
2809 =item pm_to_blib
2810
2811 Defines target that copies all files in the hash PM to their
2812 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2813
2814 =cut
2815
2816 sub pm_to_blib {
2817     my $self = shift;
2818     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2819     return q{
2820 pm_to_blib: $(TO_INST_PM)
2821         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2822         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2823         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2824         }.$self->{NOECHO}.q{$(TOUCH) $@
2825 };
2826 }
2827
2828 =item post_constants (o)
2829
2830 Returns an empty string per default. Dedicated to overrides from
2831 within Makefile.PL after all constants have been defined.
2832
2833 =cut
2834
2835 sub post_constants{
2836     my($self) = shift;
2837     "";
2838 }
2839
2840 =item post_initialize (o)
2841
2842 Returns an empty string per default. Used in Makefile.PLs to add some
2843 chunk of text to the Makefile after the object is initialized.
2844
2845 =cut
2846
2847 sub post_initialize {
2848     my($self) = shift;
2849     "";
2850 }
2851
2852 =item postamble (o)
2853
2854 Returns an empty string. Can be used in Makefile.PLs to write some
2855 text to the Makefile at the end.
2856
2857 =cut
2858
2859 sub postamble {
2860     my($self) = shift;
2861     "";
2862 }
2863
2864 =item prefixify
2865
2866 Check a path variable in $self from %Config, if it contains a prefix,
2867 and replace it with another one.
2868
2869 Takes as arguments an attribute name, a search prefix and a
2870 replacement prefix. Changes the attribute in the object.
2871
2872 =cut
2873
2874 sub prefixify {
2875     my($self,$var,$sprefix,$rprefix) = @_;
2876     $self->{uc $var} ||= $Config{lc $var};
2877     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2878     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2879 }
2880
2881 =item processPL (o)
2882
2883 Defines targets to run *.PL files.
2884
2885 =cut
2886
2887 sub processPL {
2888     my($self) = shift;
2889     return "" unless $self->{PL_FILES};
2890     my(@m, $plfile);
2891     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2892         push @m, "
2893 all :: $self->{PL_FILES}->{$plfile}
2894         $self->{NOECHO}\$(NOOP)
2895
2896 $self->{PL_FILES}->{$plfile} :: $plfile
2897         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2898 ";
2899     }
2900     join "", @m;
2901 }
2902
2903 =item realclean (o)
2904
2905 Defines the realclean target.
2906
2907 =cut
2908
2909 sub realclean {
2910     my($self, %attribs) = @_;
2911     my(@m);
2912     push(@m,'
2913 # Delete temporary files (via clean) and also delete installed files
2914 realclean purge ::  clean
2915 ');
2916     # realclean subdirectories first (already cleaned)
2917     my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2918     foreach(@{$self->{DIR}}){
2919         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2920         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2921     }
2922     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2923     if( $self->has_link_code ){
2924         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2925         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
2926     }
2927     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n")
2928         if keys %{$self->{PM}};
2929     my(@otherfiles) = ($self->{MAKEFILE},
2930                        "$self->{MAKEFILE}.old"); # Makefiles last
2931     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2932     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2933     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2934     join("", @m);
2935 }
2936
2937 =item replace_manpage_separator
2938
2939 Takes the name of a package, which may be a nested package, in the
2940 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2941
2942 =cut
2943
2944 sub replace_manpage_separator {
2945     my($self,$man) = @_;
2946     $man =~ s,/+,::,g;
2947     $man;
2948 }
2949
2950 =item static (o)
2951
2952 Defines the static target.
2953
2954 =cut
2955
2956 sub static {
2957 # --- Static Loading Sections ---
2958
2959     my($self) = shift;
2960     '
2961 ## $(INST_PM) has been moved to the all: target.
2962 ## It remains here for awhile to allow for old usage: "make static"
2963 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2964 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2965         '.$self->{NOECHO}.'$(NOOP)
2966 ';
2967 }
2968
2969 =item static_lib (o)
2970
2971 Defines how to produce the *.a (or equivalent) files.
2972
2973 =cut
2974
2975 sub static_lib {
2976     my($self) = @_;
2977 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2978 #    return '' unless $self->needs_linking(); #might be because of a subdir
2979
2980     return '' unless $self->has_link_code;
2981
2982     my(@m);
2983     push(@m, <<'END');
2984 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2985         $(RM_RF) $@
2986 END
2987     # If this extension has it's own library (eg SDBM_File)
2988     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2989     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2990
2991     push @m,
2992 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2993         $(CHMOD) $(PERM_RWX) $@
2994         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2995 };
2996     # Old mechanism - still available:
2997     push @m,
2998 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2999 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3000     push @m, "\n";
3001
3002     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3003     join('', "\n",@m);
3004 }
3005
3006 =item staticmake (o)
3007
3008 Calls makeaperl.
3009
3010 =cut
3011
3012 sub staticmake {
3013     my($self, %attribs) = @_;
3014     my(@static);
3015
3016     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3017
3018     # And as it's not yet built, we add the current extension
3019     # but only if it has some C code (or XS code, which implies C code)
3020     if (@{$self->{C}}) {
3021         @static = $self->catfile($self->{INST_ARCHLIB},
3022                                  "auto",
3023                                  $self->{FULLEXT},
3024                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3025                                 );
3026     }
3027
3028     # Either we determine now, which libraries we will produce in the
3029     # subdirectories or we do it at runtime of the make.
3030
3031     # We could ask all subdir objects, but I cannot imagine, why it
3032     # would be necessary.
3033
3034     # Instead we determine all libraries for the new perl at
3035     # runtime.
3036     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3037
3038     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3039                      DIRS       => \@searchdirs,
3040                      STAT       => \@static,
3041                      INCL       => \@perlinc,
3042                      TARGET     => $self->{MAP_TARGET},
3043                      TMP        => "",
3044                      LIBPERL    => $self->{LIBPERL_A}
3045                     );
3046 }
3047
3048 =item subdir_x (o)
3049
3050 Helper subroutine for subdirs
3051
3052 =cut
3053
3054 sub subdir_x {
3055     my($self, $subdir) = @_;
3056     my(@m);
3057     qq{
3058
3059 subdirs ::
3060         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3061
3062 };
3063 }
3064
3065 =item subdirs (o)
3066
3067 Defines targets to process subdirectories.
3068
3069 =cut
3070
3071 sub subdirs {
3072 # --- Sub-directory Sections ---
3073     my($self) = shift;
3074     my(@m,$dir);
3075     # This method provides a mechanism to automatically deal with
3076     # subdirectories containing further Makefile.PL scripts.
3077     # It calls the subdir_x() method for each subdirectory.
3078     foreach $dir (@{$self->{DIR}}){
3079         push(@m, $self->subdir_x($dir));
3080 ####    print "Including $dir subdirectory\n";
3081     }
3082     if (@m){
3083         unshift(@m, "
3084 # The default clean, realclean and test targets in this Makefile
3085 # have automatically been given entries for each subdir.
3086
3087 ");
3088     } else {
3089         push(@m, "\n# none")
3090     }
3091     join('',@m);
3092 }
3093
3094 =item test (o)
3095
3096 Defines the test targets.
3097
3098 =cut
3099
3100 sub test {
3101 # --- Test and Installation Sections ---
3102
3103     my($self, %attribs) = @_;
3104     my $tests = $attribs{TESTS};
3105     if (!$tests && -d 't') {
3106         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3107     }
3108     # note: 'test.pl' name is also hardcoded in init_dirscan()
3109     my(@m);
3110     push(@m,"
3111 TEST_VERBOSE=0
3112 TEST_TYPE=test_\$(LINKTYPE)
3113 TEST_FILE = test.pl
3114 TEST_FILES = $tests
3115 TESTDB_SW = -d
3116
3117 testdb :: testdb_\$(LINKTYPE)
3118
3119 test :: \$(TEST_TYPE)
3120 ");
3121     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3122                  @{$self->{DIR}}));
3123     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3124         unless $tests or -f "test.pl" or @{$self->{DIR}};
3125     push(@m, "\n");
3126
3127     push(@m, "test_dynamic :: pure_all\n");
3128     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3129     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3130     push(@m, "\n");
3131
3132     push(@m, "testdb_dynamic :: pure_all\n");
3133     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3134     push(@m, "\n");
3135
3136     # Occasionally we may face this degenerate target:
3137     push @m, "test_ : test_dynamic\n\n";
3138
3139     if ($self->needs_linking()) {
3140         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3141         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3142         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3143         push(@m, "\n");
3144         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3145         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3146         push(@m, "\n");
3147     } else {
3148         push @m, "test_static :: test_dynamic\n";
3149         push @m, "testdb_static :: testdb_dynamic\n";
3150     }
3151     join("", @m);
3152 }
3153
3154 =item test_via_harness (o)
3155
3156 Helper method to write the test targets
3157
3158 =cut
3159
3160 sub test_via_harness {
3161     my($self, $perl, $tests) = @_;
3162     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3163     "\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";
3164 }
3165
3166 =item test_via_script (o)
3167
3168 Other helper method for test.
3169
3170 =cut
3171
3172 sub test_via_script {
3173     my($self, $perl, $script) = @_;
3174     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3175     qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3176 };
3177 }
3178
3179 =item tool_autosplit (o)
3180
3181 Defines a simple perl call that runs autosplit. May be deprecated by
3182 pm_to_blib soon.
3183
3184 =cut
3185
3186 sub tool_autosplit {
3187 # --- Tool Sections ---
3188
3189     my($self, %attribs) = @_;
3190     my($asl) = "";
3191     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3192     q{
3193 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3194 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3195 };
3196 }
3197
3198 =item tools_other (o)
3199
3200 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3201 the Makefile. Also defines the perl programs MKPATH,
3202 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3203
3204 =cut
3205
3206 sub tools_other {
3207     my($self) = shift;
3208     my @m;
3209     my $bin_sh = $Config{sh} || '/bin/sh';
3210     push @m, qq{
3211 SHELL = $bin_sh
3212 };
3213
3214     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3215         push @m, "$_ = $self->{$_}\n";
3216     }
3217
3218     push @m, q{
3219 # The following is a portable way to say mkdir -p
3220 # To see which directories are created, change the if 0 to if 1
3221 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3222
3223 # This helps us to minimize the effect of the .exists files A yet
3224 # better solution would be to have a stable file in the perl
3225 # distribution with a timestamp of zero. But this solution doesn't
3226 # need any changes to the core distribution and works with older perls
3227 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3228 };
3229
3230
3231     return join "", @m if $self->{PARENT};
3232
3233     push @m, q{
3234 # Here we warn users that an old packlist file was found somewhere,
3235 # and that they should call some uninstall routine
3236 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3237 -e 'print "WARNING: I have found an old package in\n";' \\
3238 -e 'print "\t$$ARGV[0].\n";' \\
3239 -e 'print "Please make sure the two installations are not conflicting\n";'
3240
3241 UNINST=0
3242 VERBINST=1
3243
3244 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3245 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3246
3247 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3248 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3249 -e 'print "=over 4";' \
3250 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3251 -e 'print "=back";'
3252
3253 UNINSTALL =   $(PERL) -MExtUtils::Install \
3254 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3255 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3256 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3257 };
3258
3259     return join "", @m;
3260 }
3261
3262 =item tool_xsubpp (o)
3263
3264 Determines typemaps, xsubpp version, prototype behaviour.
3265
3266 =cut
3267
3268 sub tool_xsubpp {
3269     my($self) = shift;
3270     return "" unless $self->needs_linking;
3271     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3272     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3273     if( $self->{TYPEMAPS} ){
3274         my $typemap;
3275         foreach $typemap (@{$self->{TYPEMAPS}}){
3276                 if( ! -f  $typemap ){
3277                         warn "Typemap $typemap not found.\n";
3278                 }
3279                 else{
3280                         push(@tmdeps,  $typemap);
3281                 }
3282         }
3283     }
3284     push(@tmdeps, "typemap") if -f "typemap";
3285     my(@tmargs) = map("-typemap $_", @tmdeps);
3286     if( exists $self->{XSOPT} ){
3287         unshift( @tmargs, $self->{XSOPT} );
3288     }
3289
3290
3291     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3292
3293     # What are the correct thresholds for version 1 && 2 Paul?
3294     if ( $xsubpp_version > 1.923 ){
3295         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3296     } else {
3297         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3298             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3299         Your version of xsubpp is $xsubpp_version and cannot handle this.
3300         Please upgrade to a more recent version of xsubpp.
3301 };
3302         } else {
3303             $self->{XSPROTOARG} = "";
3304         }
3305     }
3306
3307     $xsubpp = $self->{CAPI} ? "xsubpp -object_capi" : "xsubpp";
3308
3309     return qq{
3310 XSUBPPDIR = $xsdir
3311 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3312 XSPROTOARG = $self->{XSPROTOARG}
3313 XSUBPPDEPS = @tmdeps
3314 XSUBPPARGS = @tmargs
3315 };
3316 };
3317
3318 sub xsubpp_version
3319 {
3320     my($self,$xsubpp) = @_;
3321     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3322
3323     my ($version) ;
3324
3325     # try to figure out the version number of the xsubpp on the system
3326
3327     # first try the -v flag, introduced in 1.921 & 2.000a2
3328
3329     return "" unless $self->needs_linking;
3330
3331     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3332     print "Running $command\n" if $Verbose >= 2;
3333     $version = `$command` ;
3334     warn "Running '$command' exits with status " . ($?>>8) if $?;
3335     chop $version ;
3336
3337     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3338
3339     # nope, then try something else
3340
3341     my $counter = '000';
3342     my ($file) = 'temp' ;
3343     $counter++ while -e "$file$counter"; # don't overwrite anything
3344     $file .= $counter;
3345
3346     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3347     print F <<EOM ;
3348 MODULE = fred PACKAGE = fred
3349
3350 int
3351 fred(a)
3352         int     a;
3353 EOM
3354
3355     close F ;
3356
3357     $command = "$self->{PERL} $xsubpp $file 2>&1";
3358     print "Running $command\n" if $Verbose >= 2;
3359     my $text = `$command` ;
3360     warn "Running '$command' exits with status " . ($?>>8) if $?;
3361     unlink $file ;
3362
3363     # gets 1.2 -> 1.92 and 2.000a1
3364     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3365
3366     # it is either 1.0 or 1.1
3367     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3368
3369     # none of the above, so 1.0
3370     return $Xsubpp_Version = "1.0" ;
3371 }
3372
3373 =item top_targets (o)
3374
3375 Defines the targets all, subdirs, config, and O_FILES
3376
3377 =cut
3378
3379 sub top_targets {
3380 # --- Target Sections ---
3381
3382     my($self) = shift;
3383     my(@m);
3384     push @m, '
3385 #all :: config $(INST_PM) subdirs linkext manifypods
3386 ';
3387
3388     push @m, '
3389 all :: pure_all manifypods
3390         '.$self->{NOECHO}.'$(NOOP)
3391 '
3392           unless $self->{SKIPHASH}{'all'};
3393
3394     push @m, '
3395 pure_all :: config pm_to_blib subdirs linkext
3396         '.$self->{NOECHO}.'$(NOOP)
3397
3398 subdirs :: $(MYEXTLIB)
3399         '.$self->{NOECHO}.'$(NOOP)
3400
3401 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3402         '.$self->{NOECHO}.'$(NOOP)
3403
3404 config :: $(INST_ARCHAUTODIR)/.exists
3405         '.$self->{NOECHO}.'$(NOOP)
3406
3407 config :: $(INST_AUTODIR)/.exists
3408         '.$self->{NOECHO}.'$(NOOP)
3409 ';
3410
3411     push @m, qq{
3412 config :: Version_check
3413         $self->{NOECHO}\$(NOOP)
3414
3415 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3416
3417     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3418
3419     if (%{$self->{MAN1PODS}}) {
3420         push @m, qq[
3421 config :: \$(INST_MAN1DIR)/.exists
3422         $self->{NOECHO}\$(NOOP)
3423
3424 ];
3425         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3426     }
3427     if (%{$self->{MAN3PODS}}) {
3428         push @m, qq[
3429 config :: \$(INST_MAN3DIR)/.exists
3430         $self->{NOECHO}\$(NOOP)
3431
3432 ];
3433         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3434     }
3435
3436     push @m, '
3437 $(O_FILES): $(H_FILES)
3438 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3439
3440     push @m, q{
3441 help:
3442         perldoc ExtUtils::MakeMaker
3443 };
3444
3445     push @m, q{
3446 Version_check:
3447         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3448                 -MExtUtils::MakeMaker=Version_check \
3449                 -e "Version_check('$(MM_VERSION)')"
3450 };
3451
3452     join('',@m);
3453 }
3454
3455 =item writedoc
3456
3457 Obsolete, depecated method. Not used since Version 5.21.
3458
3459 =cut
3460
3461 sub writedoc {
3462 # --- perllocal.pod section ---
3463     my($self,$what,$name,@attribs)=@_;
3464     my $time = localtime;
3465     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3466     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3467     print "\n\n=back\n\n";
3468 }
3469
3470 =item xs_c (o)
3471
3472 Defines the suffix rules to compile XS files to C.
3473
3474 =cut
3475
3476 sub xs_c {
3477     my($self) = shift;
3478     return '' unless $self->needs_linking();
3479     '
3480 .xs.c:
3481         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3482 ';
3483 }
3484
3485 =item xs_o (o)
3486
3487 Defines suffix rules to go from XS to object files directly. This is
3488 only intended for broken make implementations.
3489
3490 =cut
3491
3492 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3493     my($self) = shift;
3494     return '' unless $self->needs_linking();
3495     '
3496 .xs$(OBJ_EXT):
3497         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3498         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3499 ';
3500 }
3501
3502 =item perl_archive
3503
3504 This is internal method that returns path to libperl.a equivalent
3505 to be linked to dynamic extensions. UNIX does not have one but OS2
3506 and Win32 do.
3507
3508 =cut
3509
3510 sub perl_archive
3511 {
3512  return "";
3513 }
3514
3515 =item export_list
3516
3517 This is internal method that returns name of a file that is
3518 passed to linker to define symbols to be exported.
3519 UNIX does not have one but OS2 and Win32 do.
3520
3521 =cut
3522
3523 sub export_list
3524 {
3525  return "";
3526 }
3527
3528
3529 1;
3530
3531 =back
3532
3533 =head1 SEE ALSO
3534
3535 L<ExtUtils::MakeMaker>
3536
3537 =cut
3538
3539 __END__