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