lib/ExtUtils/MM_Unix.pm

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