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