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