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