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