lib/ExtUtils/MM_Unix.pm

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