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