lib/ExtUtils/MM_Unix.pm

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