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 :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2433     my($dist);
2434     my($pod2man_exe);
2435     if (defined $self->{PERL_SRC}) {
2436         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2437     } else {
2438         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2439     }
2440     unless ($self->perl_script($pod2man_exe)) {
2441         # No pod2man but some MAN3PODS to be installed
2442         print <<END;
2443
2444 Warning: I could not locate your pod2man program. Please make sure,
2445          your pod2man program is in your PATH before you execute 'make'
2446
2447 END
2448         $pod2man_exe = "-S pod2man";
2449     }
2450     my(@m);
2451     push @m,
2452 qq[POD2MAN_EXE = $pod2man_exe\n],
2453 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2454 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2455  $self->{MAKEFILE}, q[";' \\
2456 -e 'print "Manifying $$m{$$_}\n";' \\
2457 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2458 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2459 ];
2460     push @m, "\nmanifypods : ";
2461     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2462
2463     push(@m,"\n");
2464     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2465         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2466         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2467     }
2468     join('', @m);
2469 }
2470
2471 =item maybe_command
2472
2473 Returns true, if the argument is likely to be a command.
2474
2475 =cut
2476
2477 sub maybe_command {
2478     my($self,$file) = @_;
2479     return $file if -x $file && ! -d $file;
2480     return;
2481 }
2482
2483 =item maybe_command_in_dirs
2484
2485 method under development. Not yet used. Ask Ilya :-)
2486
2487 =cut
2488
2489 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2490 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2491     my($self, $names, $dirs, $trace, $ver) = @_;
2492     my($name, $dir);
2493     foreach $dir (@$dirs){
2494         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2495         foreach $name (@$names){
2496             my($abs,$tryabs);
2497             if ($self->file_name_is_absolute($name)) { # /foo/bar
2498                 $abs = $name;
2499             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2500                 $abs = $self->catfile($dir, $name);
2501             } else { # foo/bar
2502                 $abs = $self->catfile($self->curdir, $name);
2503             }
2504             print "Checking $abs for $name\n" if ($trace >= 2);
2505             next unless $tryabs = $self->maybe_command($abs);
2506             print "Substituting $tryabs instead of $abs\n"
2507                 if ($trace >= 2 and $tryabs ne $abs);
2508             $abs = $tryabs;
2509             if (defined $ver) {
2510                 print "Executing $abs\n" if ($trace >= 2);
2511                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2512                     print "Using PERL=$abs\n" if $trace;
2513                     return $abs;
2514                 }
2515             } else { # Do not look for perl
2516                 return $abs;
2517             }
2518         }
2519     }
2520 }
2521
2522 =item needs_linking (o)
2523
2524 Does this module need linking? Looks into subdirectory objects (see
2525 also has_link_code())
2526
2527 =cut
2528
2529 sub needs_linking {
2530     my($self) = shift;
2531     my($child,$caller);
2532     $caller = (caller(0))[3];
2533     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2534     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2535     if ($self->has_link_code or $self->{MAKEAPERL}){
2536         $self->{NEEDS_LINKING} = 1;
2537         return 1;
2538     }
2539     foreach $child (keys %{$self->{CHILDREN}}) {
2540         if ($self->{CHILDREN}->{$child}->needs_linking) {
2541             $self->{NEEDS_LINKING} = 1;
2542             return 1;
2543         }
2544     }
2545     return $self->{NEEDS_LINKING} = 0;
2546 }
2547
2548 =item nicetext
2549
2550 misnamed method (will have to be changed). The MM_Unix method just
2551 returns the argument without further processing.
2552
2553 On VMS used to insure that colons marking targets are preceded by
2554 space - most Unix Makes don't need this, but it's necessary under VMS
2555 to distinguish the target delimiter from a colon appearing as part of
2556 a filespec.
2557
2558 =cut
2559
2560 sub nicetext {
2561     my($self,$text) = @_;
2562     $text;
2563 }
2564
2565 =item parse_version
2566
2567 parse a file and return what you think is $VERSION in this file set to
2568
2569 =cut
2570
2571 sub parse_version {
2572     my($self,$parsefile) = @_;
2573     my $result;
2574     local *FH;
2575     local $/ = "\n";
2576     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2577     my $inpod = 0;
2578     while (<FH>) {
2579         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2580         next if $inpod;
2581         chop;
2582         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2583         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2584         my $eval = qq{
2585             package ExtUtils::MakeMaker::_version;
2586             no strict;
2587
2588             local $1$2;
2589             \$$2=undef; do {
2590                 $_
2591             }; \$$2
2592         };
2593         local($^W) = 0;
2594         $result = eval($eval);
2595         die "Could not eval '$eval' in $parsefile: $@" if $@;
2596         $result = "undef" unless defined $result;
2597         last;
2598     }
2599     close FH;
2600     return $result;
2601 }
2602
2603 =item parse_abstract
2604
2605 parse a file and return what you think is the ABSTRACT
2606
2607 =cut
2608
2609 sub parse_abstract {
2610     my($self,$parsefile) = @_;
2611     my $result;
2612     local *FH;
2613     local $/ = "\n";
2614     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2615     my $inpod = 0;
2616     my $package = $self->{DISTNAME};
2617     $package =~ s/-/::/;
2618     while (<FH>) {
2619         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2620         next if !$inpod;
2621         chop;
2622         next unless /^($package\s-\s)(.*)/;
2623         $result = $2;
2624         last;
2625     }
2626     close FH;
2627     return $result;
2628 }
2629
2630 =item pasthru (o)
2631
2632 Defines the string that is passed to recursive make calls in
2633 subdirectories.
2634
2635 =cut
2636
2637 sub pasthru {
2638     my($self) = shift;
2639     my(@m,$key);
2640
2641     my(@pasthru);
2642     my($sep) = $Is_VMS ? ',' : '';
2643     $sep .= "\\\n\t";
2644
2645     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2646         push @pasthru, "$key=\"\$($key)\"";
2647     }
2648
2649     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2650     join "", @m;
2651 }
2652
2653 =item path
2654
2655 Takes no argument, returns the environment variable PATH as an array.
2656
2657 =cut
2658
2659 sub path {
2660     my($self) = @_;
2661     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2662     my $path = $ENV{PATH};
2663     $path =~ s:\\:/:g if $Is_OS2;
2664     my @path = split $path_sep, $path;
2665     foreach(@path) { $_ = '.' if $_ eq '' }
2666     @path;
2667 }
2668
2669 =item perl_script
2670
2671 Takes one argument, a file name, and returns the file name, if the
2672 argument is likely to be a perl script. On MM_Unix this is true for
2673 any ordinary, readable file.
2674
2675 =cut
2676
2677 sub perl_script {
2678     my($self,$file) = @_;
2679     return $file if -r $file && -f _;
2680     return;
2681 }
2682
2683 =item perldepend (o)
2684
2685 Defines the dependency from all *.h files that come with the perl
2686 distribution.
2687
2688 =cut
2689
2690 sub perldepend {
2691     my($self) = shift;
2692     my(@m);
2693     push @m, q{
2694 # Check for unpropogated config.sh changes. Should never happen.
2695 # We do NOT just update config.h because that is not sufficient.
2696 # An out of date config.h is not fatal but complains loudly!
2697 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2698         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2699
2700 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2701         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2702         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2703 } if $self->{PERL_SRC};
2704
2705     return join "", @m unless $self->needs_linking;
2706
2707     push @m, q{
2708 PERL_HDRS = \
2709 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2710 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2711 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2712 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2713 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2714 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2715 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2716 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2717 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h         $(PERL_INC)/iperlsys.h \
2718 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2719
2720 $(OBJECT) : $(PERL_HDRS)
2721 } if $self->{OBJECT};
2722
2723     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2724
2725     join "\n", @m;
2726 }
2727
2728 =item ppd
2729
2730 Defines target that creates a PPD (Perl Package Description) file
2731 for a binary distribution.
2732
2733 =cut
2734
2735 sub ppd {
2736     my($self) = @_;
2737     my(@m);
2738     if ($self->{ABSTRACT_FROM}){
2739         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2740             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2741     }
2742     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2743     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2744     push(@m, "ppd:\n");
2745     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2746     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2747     my $abstract = $self->{ABSTRACT};
2748     $abstract =~ s/</&lt;/g;
2749     $abstract =~ s/>/&gt;/g;
2750     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2751     my ($author) = $self->{AUTHOR};
2752     $author =~ s/@/\\@/g;
2753     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2754     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2755     my ($prereq);
2756     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2757         my $pre_req = $prereq;
2758         $pre_req =~ s/::/-/g;
2759         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" />\\n}");
2760     }
2761     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
2762     my ($bin_location) = $self->{BINARY_LOCATION};
2763     $bin_location =~ s/\\/\\\\/g;
2764     if ($self->{PPM_INSTALL_SCRIPT}) {
2765         if ($self->{PPM_INSTALL_EXEC}) {
2766             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2767         }
2768         else {
2769             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2770         }
2771     }
2772     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
2773     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
2774     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
2775
2776     join("", @m);
2777 }
2778
2779 =item perm_rw (o)
2780
2781 Returns the attribute C<PERM_RW> or the string C<644>.
2782 Used as the string that is passed
2783 to the C<chmod> command to set the permissions for read/writeable files.
2784 MakeMaker chooses C<644> because it has turned out in the past that
2785 relying on the umask provokes hard-to-track bugreports.
2786 When the return value is used by the perl function C<chmod>, it is
2787 interpreted as an octal value.
2788
2789 =cut
2790
2791 sub perm_rw {
2792     shift->{PERM_RW} || "644";
2793 }
2794
2795 =item perm_rwx (o)
2796
2797 Returns the attribute C<PERM_RWX> or the string C<755>,
2798 i.e. the string that is passed
2799 to the C<chmod> command to set the permissions for executable files.
2800 See also perl_rw.
2801
2802 =cut
2803
2804 sub perm_rwx {
2805     shift->{PERM_RWX} || "755";
2806 }
2807
2808 =item pm_to_blib
2809
2810 Defines target that copies all files in the hash PM to their
2811 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2812
2813 =cut
2814
2815 sub pm_to_blib {
2816     my $self = shift;
2817     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2818     return q{
2819 pm_to_blib: $(TO_INST_PM)
2820         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2821         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2822         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2823         }.$self->{NOECHO}.q{$(TOUCH) $@
2824 };
2825 }
2826
2827 =item post_constants (o)
2828
2829 Returns an empty string per default. Dedicated to overrides from
2830 within Makefile.PL after all constants have been defined.
2831
2832 =cut
2833
2834 sub post_constants{
2835     my($self) = shift;
2836     "";
2837 }
2838
2839 =item post_initialize (o)
2840
2841 Returns an empty string per default. Used in Makefile.PLs to add some
2842 chunk of text to the Makefile after the object is initialized.
2843
2844 =cut
2845
2846 sub post_initialize {
2847     my($self) = shift;
2848     "";
2849 }
2850
2851 =item postamble (o)
2852
2853 Returns an empty string. Can be used in Makefile.PLs to write some
2854 text to the Makefile at the end.
2855
2856 =cut
2857
2858 sub postamble {
2859     my($self) = shift;
2860     "";
2861 }
2862
2863 =item prefixify
2864
2865 Check a path variable in $self from %Config, if it contains a prefix,
2866 and replace it with another one.
2867
2868 Takes as arguments an attribute name, a search prefix and a
2869 replacement prefix. Changes the attribute in the object.
2870
2871 =cut
2872
2873 sub prefixify {
2874     my($self,$var,$sprefix,$rprefix) = @_;
2875     $self->{uc $var} ||= $Config{lc $var};
2876     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2877     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2878 }
2879
2880 =item processPL (o)
2881
2882 Defines targets to run *.PL files.
2883
2884 =cut
2885
2886 sub processPL {
2887     my($self) = shift;
2888     return "" unless $self->{PL_FILES};
2889     my(@m, $plfile);
2890     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2891         push @m, "
2892 all :: $self->{PL_FILES}->{$plfile}
2893         $self->{NOECHO}\$(NOOP)
2894
2895 $self->{PL_FILES}->{$plfile} :: $plfile
2896         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2897 ";
2898     }
2899     join "", @m;
2900 }
2901
2902 =item realclean (o)
2903
2904 Defines the realclean target.
2905
2906 =cut
2907
2908 sub realclean {
2909     my($self, %attribs) = @_;
2910     my(@m);
2911     push(@m,'
2912 # Delete temporary files (via clean) and also delete installed files
2913 realclean purge ::  clean
2914 ');
2915     # realclean subdirectories first (already cleaned)
2916     my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2917     foreach(@{$self->{DIR}}){
2918         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2919         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2920     }
2921     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2922     if( $self->has_link_code ){
2923         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2924         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
2925     }
2926     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n")
2927         if keys %{$self->{PM}};
2928     my(@otherfiles) = ($self->{MAKEFILE},
2929                        "$self->{MAKEFILE}.old"); # Makefiles last
2930     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2931     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2932     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2933     join("", @m);
2934 }
2935
2936 =item replace_manpage_separator
2937
2938 Takes the name of a package, which may be a nested package, in the
2939 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2940
2941 =cut
2942
2943 sub replace_manpage_separator {
2944     my($self,$man) = @_;
2945     $man =~ s,/+,::,g;
2946     $man;
2947 }
2948
2949 =item static (o)
2950
2951 Defines the static target.
2952
2953 =cut
2954
2955 sub static {
2956 # --- Static Loading Sections ---
2957
2958     my($self) = shift;
2959     '
2960 ## $(INST_PM) has been moved to the all: target.
2961 ## It remains here for awhile to allow for old usage: "make static"
2962 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2963 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2964         '.$self->{NOECHO}.'$(NOOP)
2965 ';
2966 }
2967
2968 =item static_lib (o)
2969
2970 Defines how to produce the *.a (or equivalent) files.
2971
2972 =cut
2973
2974 sub static_lib {
2975     my($self) = @_;
2976 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2977 #    return '' unless $self->needs_linking(); #might be because of a subdir
2978
2979     return '' unless $self->has_link_code;
2980
2981     my(@m);
2982     push(@m, <<'END');
2983 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2984         $(RM_RF) $@
2985 END
2986     # If this extension has it's own library (eg SDBM_File)
2987     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2988     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2989
2990     push @m,
2991 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2992         $(CHMOD) $(PERM_RWX) $@
2993         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2994 };
2995     # Old mechanism - still available:
2996     push @m,
2997 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2998 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
2999     push @m, "\n";
3000
3001     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3002     join('', "\n",@m);
3003 }
3004
3005 =item staticmake (o)
3006
3007 Calls makeaperl.
3008
3009 =cut
3010
3011 sub staticmake {
3012     my($self, %attribs) = @_;
3013     my(@static);
3014
3015     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3016
3017     # And as it's not yet built, we add the current extension
3018     # but only if it has some C code (or XS code, which implies C code)
3019     if (@{$self->{C}}) {
3020         @static = $self->catfile($self->{INST_ARCHLIB},
3021                                  "auto",
3022                                  $self->{FULLEXT},
3023                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3024                                 );
3025     }
3026
3027     # Either we determine now, which libraries we will produce in the
3028     # subdirectories or we do it at runtime of the make.
3029
3030     # We could ask all subdir objects, but I cannot imagine, why it
3031     # would be necessary.
3032
3033     # Instead we determine all libraries for the new perl at
3034     # runtime.
3035     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3036
3037     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3038                      DIRS       => \@searchdirs,
3039                      STAT       => \@static,
3040                      INCL       => \@perlinc,
3041                      TARGET     => $self->{MAP_TARGET},
3042                      TMP        => "",
3043                      LIBPERL    => $self->{LIBPERL_A}
3044                     );
3045 }
3046
3047 =item subdir_x (o)
3048
3049 Helper subroutine for subdirs
3050
3051 =cut
3052
3053 sub subdir_x {
3054     my($self, $subdir) = @_;
3055     my(@m);
3056     qq{
3057
3058 subdirs ::
3059         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3060
3061 };
3062 }
3063
3064 =item subdirs (o)
3065
3066 Defines targets to process subdirectories.
3067
3068 =cut
3069
3070 sub subdirs {
3071 # --- Sub-directory Sections ---
3072     my($self) = shift;
3073     my(@m,$dir);
3074     # This method provides a mechanism to automatically deal with
3075     # subdirectories containing further Makefile.PL scripts.
3076     # It calls the subdir_x() method for each subdirectory.
3077     foreach $dir (@{$self->{DIR}}){
3078         push(@m, $self->subdir_x($dir));
3079 ####    print "Including $dir subdirectory\n";
3080     }
3081     if (@m){
3082         unshift(@m, "
3083 # The default clean, realclean and test targets in this Makefile
3084 # have automatically been given entries for each subdir.
3085
3086 ");
3087     } else {
3088         push(@m, "\n# none")
3089     }
3090     join('',@m);
3091 }
3092
3093 =item test (o)
3094
3095 Defines the test targets.
3096
3097 =cut
3098
3099 sub test {
3100 # --- Test and Installation Sections ---
3101
3102     my($self, %attribs) = @_;
3103     my $tests = $attribs{TESTS};
3104     if (!$tests && -d 't') {
3105         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3106     }
3107     # note: 'test.pl' name is also hardcoded in init_dirscan()
3108     my(@m);
3109     push(@m,"
3110 TEST_VERBOSE=0
3111 TEST_TYPE=test_\$(LINKTYPE)
3112 TEST_FILE = test.pl
3113 TEST_FILES = $tests
3114 TESTDB_SW = -d
3115
3116 testdb :: testdb_\$(LINKTYPE)
3117
3118 test :: \$(TEST_TYPE)
3119 ");
3120     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3121                  @{$self->{DIR}}));
3122     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3123         unless $tests or -f "test.pl" or @{$self->{DIR}};
3124     push(@m, "\n");
3125
3126     push(@m, "test_dynamic :: pure_all\n");
3127     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3128     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3129     push(@m, "\n");
3130
3131     push(@m, "testdb_dynamic :: pure_all\n");
3132     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3133     push(@m, "\n");
3134
3135     # Occasionally we may face this degenerate target:
3136     push @m, "test_ : test_dynamic\n\n";
3137
3138     if ($self->needs_linking()) {
3139         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3140         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3141         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3142         push(@m, "\n");
3143         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3144         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3145         push(@m, "\n");
3146     } else {
3147         push @m, "test_static :: test_dynamic\n";
3148         push @m, "testdb_static :: testdb_dynamic\n";
3149     }
3150     join("", @m);
3151 }
3152
3153 =item test_via_harness (o)
3154
3155 Helper method to write the test targets
3156
3157 =cut
3158
3159 sub test_via_harness {
3160     my($self, $perl, $tests) = @_;
3161     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3162     "\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";
3163 }
3164
3165 =item test_via_script (o)
3166
3167 Other helper method for test.
3168
3169 =cut
3170
3171 sub test_via_script {
3172     my($self, $perl, $script) = @_;
3173     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3174     qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3175 };
3176 }
3177
3178 =item tool_autosplit (o)
3179
3180 Defines a simple perl call that runs autosplit. May be deprecated by
3181 pm_to_blib soon.
3182
3183 =cut
3184
3185 sub tool_autosplit {
3186 # --- Tool Sections ---
3187
3188     my($self, %attribs) = @_;
3189     my($asl) = "";
3190     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3191     q{
3192 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3193 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3194 };
3195 }
3196
3197 =item tools_other (o)
3198
3199 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3200 the Makefile. Also defines the perl programs MKPATH,
3201 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3202
3203 =cut
3204
3205 sub tools_other {
3206     my($self) = shift;
3207     my @m;
3208     my $bin_sh = $Config{sh} || '/bin/sh';
3209     push @m, qq{
3210 SHELL = $bin_sh
3211 };
3212
3213     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3214         push @m, "$_ = $self->{$_}\n";
3215     }
3216
3217     push @m, q{
3218 # The following is a portable way to say mkdir -p
3219 # To see which directories are created, change the if 0 to if 1
3220 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3221
3222 # This helps us to minimize the effect of the .exists files A yet
3223 # better solution would be to have a stable file in the perl
3224 # distribution with a timestamp of zero. But this solution doesn't
3225 # need any changes to the core distribution and works with older perls
3226 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3227 };
3228
3229
3230     return join "", @m if $self->{PARENT};
3231
3232     push @m, q{
3233 # Here we warn users that an old packlist file was found somewhere,
3234 # and that they should call some uninstall routine
3235 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3236 -e 'print "WARNING: I have found an old package in\n";' \\
3237 -e 'print "\t$$ARGV[0].\n";' \\
3238 -e 'print "Please make sure the two installations are not conflicting\n";'
3239
3240 UNINST=0
3241 VERBINST=1
3242
3243 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3244 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3245
3246 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3247 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3248 -e 'print "=over 4";' \
3249 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3250 -e 'print "=back";'
3251
3252 UNINSTALL =   $(PERL) -MExtUtils::Install \
3253 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3254 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3255 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3256 };
3257
3258     return join "", @m;
3259 }
3260
3261 =item tool_xsubpp (o)
3262
3263 Determines typemaps, xsubpp version, prototype behaviour.
3264
3265 =cut
3266
3267 sub tool_xsubpp {
3268     my($self) = shift;
3269     return "" unless $self->needs_linking;
3270     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3271     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3272     if( $self->{TYPEMAPS} ){
3273         my $typemap;
3274         foreach $typemap (@{$self->{TYPEMAPS}}){
3275                 if( ! -f  $typemap ){
3276                         warn "Typemap $typemap not found.\n";
3277                 }
3278                 else{
3279                         push(@tmdeps,  $typemap);
3280                 }
3281         }
3282     }
3283     push(@tmdeps, "typemap") if -f "typemap";
3284     my(@tmargs) = map("-typemap $_", @tmdeps);
3285     if( exists $self->{XSOPT} ){
3286         unshift( @tmargs, $self->{XSOPT} );
3287     }
3288
3289
3290     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3291
3292     # What are the correct thresholds for version 1 && 2 Paul?
3293     if ( $xsubpp_version > 1.923 ){
3294         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3295     } else {
3296         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3297             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3298         Your version of xsubpp is $xsubpp_version and cannot handle this.
3299         Please upgrade to a more recent version of xsubpp.
3300 };
3301         } else {
3302             $self->{XSPROTOARG} = "";
3303         }
3304     }
3305
3306     $xsubpp = $self->{CAPI} ? "xsubpp -object_capi" : "xsubpp";
3307
3308     return qq{
3309 XSUBPPDIR = $xsdir
3310 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3311 XSPROTOARG = $self->{XSPROTOARG}
3312 XSUBPPDEPS = @tmdeps
3313 XSUBPPARGS = @tmargs
3314 };
3315 };
3316
3317 sub xsubpp_version
3318 {
3319     my($self,$xsubpp) = @_;
3320     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3321
3322     my ($version) ;
3323
3324     # try to figure out the version number of the xsubpp on the system
3325
3326     # first try the -v flag, introduced in 1.921 & 2.000a2
3327
3328     return "" unless $self->needs_linking;
3329
3330     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3331     print "Running $command\n" if $Verbose >= 2;
3332     $version = `$command` ;
3333     warn "Running '$command' exits with status " . ($?>>8) if $?;
3334     chop $version ;
3335
3336     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3337
3338     # nope, then try something else
3339
3340     my $counter = '000';
3341     my ($file) = 'temp' ;
3342     $counter++ while -e "$file$counter"; # don't overwrite anything
3343     $file .= $counter;
3344
3345     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3346     print F <<EOM ;
3347 MODULE = fred PACKAGE = fred
3348
3349 int
3350 fred(a)
3351         int     a;
3352 EOM
3353
3354     close F ;
3355
3356     $command = "$self->{PERL} $xsubpp $file 2>&1";
3357     print "Running $command\n" if $Verbose >= 2;
3358     my $text = `$command` ;
3359     warn "Running '$command' exits with status " . ($?>>8) if $?;
3360     unlink $file ;
3361
3362     # gets 1.2 -> 1.92 and 2.000a1
3363     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3364
3365     # it is either 1.0 or 1.1
3366     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3367
3368     # none of the above, so 1.0
3369     return $Xsubpp_Version = "1.0" ;
3370 }
3371
3372 =item top_targets (o)
3373
3374 Defines the targets all, subdirs, config, and O_FILES
3375
3376 =cut
3377
3378 sub top_targets {
3379 # --- Target Sections ---
3380
3381     my($self) = shift;
3382     my(@m);
3383     push @m, '
3384 #all :: config $(INST_PM) subdirs linkext manifypods
3385 ';
3386
3387     push @m, '
3388 all :: pure_all manifypods
3389         '.$self->{NOECHO}.'$(NOOP)
3390 '
3391           unless $self->{SKIPHASH}{'all'};
3392
3393     push @m, '
3394 pure_all :: config pm_to_blib subdirs linkext
3395         '.$self->{NOECHO}.'$(NOOP)
3396
3397 subdirs :: $(MYEXTLIB)
3398         '.$self->{NOECHO}.'$(NOOP)
3399
3400 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3401         '.$self->{NOECHO}.'$(NOOP)
3402
3403 config :: $(INST_ARCHAUTODIR)/.exists
3404         '.$self->{NOECHO}.'$(NOOP)
3405
3406 config :: $(INST_AUTODIR)/.exists
3407         '.$self->{NOECHO}.'$(NOOP)
3408 ';
3409
3410     push @m, qq{
3411 config :: Version_check
3412         $self->{NOECHO}\$(NOOP)
3413
3414 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3415
3416     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3417
3418     if (%{$self->{MAN1PODS}}) {
3419         push @m, qq[
3420 config :: \$(INST_MAN1DIR)/.exists
3421         $self->{NOECHO}\$(NOOP)
3422
3423 ];
3424         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3425     }
3426     if (%{$self->{MAN3PODS}}) {
3427         push @m, qq[
3428 config :: \$(INST_MAN3DIR)/.exists
3429         $self->{NOECHO}\$(NOOP)
3430
3431 ];
3432         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3433     }
3434
3435     push @m, '
3436 $(O_FILES): $(H_FILES)
3437 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3438
3439     push @m, q{
3440 help:
3441         perldoc ExtUtils::MakeMaker
3442 };
3443
3444     push @m, q{
3445 Version_check:
3446         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3447                 -MExtUtils::MakeMaker=Version_check \
3448                 -e "Version_check('$(MM_VERSION)')"
3449 };
3450
3451     join('',@m);
3452 }
3453
3454 =item writedoc
3455
3456 Obsolete, depecated method. Not used since Version 5.21.
3457
3458 =cut
3459
3460 sub writedoc {
3461 # --- perllocal.pod section ---
3462     my($self,$what,$name,@attribs)=@_;
3463     my $time = localtime;
3464     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3465     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3466     print "\n\n=back\n\n";
3467 }
3468
3469 =item xs_c (o)
3470
3471 Defines the suffix rules to compile XS files to C.
3472
3473 =cut
3474
3475 sub xs_c {
3476     my($self) = shift;
3477     return '' unless $self->needs_linking();
3478     '
3479 .xs.c:
3480         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3481 ';
3482 }
3483
3484 =item xs_o (o)
3485
3486 Defines suffix rules to go from XS to object files directly. This is
3487 only intended for broken make implementations.
3488
3489 =cut
3490
3491 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3492     my($self) = shift;
3493     return '' unless $self->needs_linking();
3494     '
3495 .xs$(OBJ_EXT):
3496         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3497         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3498 ';
3499 }
3500
3501 =item perl_archive
3502
3503 This is internal method that returns path to libperl.a equivalent
3504 to be linked to dynamic extensions. UNIX does not have one but OS2
3505 and Win32 do.
3506
3507 =cut
3508
3509 sub perl_archive
3510 {
3511  return "";
3512 }
3513
3514 =item export_list
3515
3516 This is internal method that returns name of a file that is
3517 passed to linker to define symbols to be exported.
3518 UNIX does not have one but OS2 and Win32 do.
3519
3520 =cut
3521
3522 sub export_list
3523 {
3524  return "";
3525 }
3526
3527
3528 1;
3529
3530 =back
3531
3532 =head1 SEE ALSO
3533
3534 L<ExtUtils::MakeMaker>
3535
3536 =cut
3537
3538 __END__