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{$(MKPATH) $(INSTALLARCHLIB)
2139         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2140                 "Module" "$(NAME)" \
2141                 "installed into" "$(INSTALLPRIVLIB)" \
2142                 LINKTYPE "$(LINKTYPE)" \
2143                 VERSION "$(VERSION)" \
2144                 EXE_FILES "$(EXE_FILES)" \
2145                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2146
2147 doc_site_install ::
2148         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2149         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2150                 "Module" "$(NAME)" \
2151                 "installed into" "$(INSTALLSITELIB)" \
2152                 LINKTYPE "$(LINKTYPE)" \
2153                 VERSION "$(VERSION)" \
2154                 EXE_FILES "$(EXE_FILES)" \
2155                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2156
2157 };
2158
2159     push @m, q{
2160 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2161
2162 uninstall_from_perldirs ::
2163         }.$self->{NOECHO}.
2164         q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2165
2166 uninstall_from_sitedirs ::
2167         }.$self->{NOECHO}.
2168         q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2169 };
2170
2171     join("",@m);
2172 }
2173
2174 =item installbin (o)
2175
2176 Defines targets to make and to install EXE_FILES.
2177
2178 =cut
2179
2180 sub installbin {
2181     my($self) = shift;
2182     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2183     return "" unless @{$self->{EXE_FILES}};
2184     my(@m, $from, $to, %fromto, @to);
2185     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2186     for $from (@{$self->{EXE_FILES}}) {
2187         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2188         local($_) = $path; # for backwards compatibility
2189         $to = $self->libscan($path);
2190         print "libscan($from) => '$to'\n" if ($Verbose >=2);
2191         $fromto{$from}=$to;
2192     }
2193     @to   = values %fromto;
2194     push(@m, qq{
2195 EXE_FILES = @{$self->{EXE_FILES}}
2196
2197 } . ($Is_Win32
2198   ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2199     -e "system qq[pl2bat.bat ].shift"
2200 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2201     -e "MY->fixin(shift)"
2202 }).qq{
2203 pure_all :: @to
2204         $self->{NOECHO}\$(NOOP)
2205
2206 realclean ::
2207         $self->{RM_F} @to
2208 });
2209
2210     while (($from,$to) = each %fromto) {
2211         last unless defined $from;
2212         my $todir = dirname($to);
2213         push @m, "
2214 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2215         $self->{NOECHO}$self->{RM_F} $to
2216         $self->{CP} $from $to
2217         \$(FIXIN) $to
2218         -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2219 ";
2220     }
2221     join "", @m;
2222 }
2223
2224 =item libscan (o)
2225
2226 Takes a path to a file that is found by init_dirscan and returns false
2227 if we don't want to include this file in the library. Mainly used to
2228 exclude RCS, CVS, and SCCS directories from installation.
2229
2230 =cut
2231
2232 # ';
2233
2234 sub libscan {
2235     my($self,$path) = @_;
2236     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2237     $path;
2238 }
2239
2240 =item linkext (o)
2241
2242 Defines the linkext target which in turn defines the LINKTYPE.
2243
2244 =cut
2245
2246 sub linkext {
2247     my($self, %attribs) = @_;
2248     # LINKTYPE => static or dynamic or ''
2249     my($linktype) = defined $attribs{LINKTYPE} ?
2250       $attribs{LINKTYPE} : '$(LINKTYPE)';
2251     "
2252 linkext :: $linktype
2253         $self->{NOECHO}\$(NOOP)
2254 ";
2255 }
2256
2257 =item lsdir
2258
2259 Takes as arguments a directory name and a regular expression. Returns
2260 all entries in the directory that match the regular expression.
2261
2262 =cut
2263
2264 sub lsdir {
2265     my($self) = shift;
2266     my($dir, $regex) = @_;
2267     my(@ls);
2268     my $dh = new DirHandle;
2269     $dh->open($dir || ".") or return ();
2270     @ls = $dh->read;
2271     $dh->close;
2272     @ls = grep(/$regex/, @ls) if $regex;
2273     @ls;
2274 }
2275
2276 =item macro (o)
2277
2278 Simple subroutine to insert the macros defined by the macro attribute
2279 into the Makefile.
2280
2281 =cut
2282
2283 sub macro {
2284     my($self,%attribs) = @_;
2285     my(@m,$key,$val);
2286     while (($key,$val) = each %attribs){
2287         last unless defined $key;
2288         push @m, "$key = $val\n";
2289     }
2290     join "", @m;
2291 }
2292
2293 =item makeaperl (o)
2294
2295 Called by staticmake. Defines how to write the Makefile to produce a
2296 static new perl.
2297
2298 By default the Makefile produced includes all the static extensions in
2299 the perl library. (Purified versions of library files, e.g.,
2300 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2301
2302 =cut
2303
2304 sub makeaperl {
2305     my($self, %attribs) = @_;
2306     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2307         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2308     my(@m);
2309     push @m, "
2310 # --- MakeMaker makeaperl section ---
2311 MAP_TARGET    = $target
2312 FULLPERL      = $self->{FULLPERL}
2313 ";
2314     return join '', @m if $self->{PARENT};
2315
2316     my($dir) = join ":", @{$self->{DIR}};
2317
2318     unless ($self->{MAKEAPERL}) {
2319         push @m, q{
2320 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2321         $(MAKE) -f $(MAKE_APERL_FILE) $@
2322
2323 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2324         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2325         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2326                 Makefile.PL DIR=}, $dir, q{ \
2327                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2328                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2329
2330         foreach (@ARGV){
2331                 if( /\s/ ){
2332                         s/=(.*)/='$1'/;
2333                 }
2334                 push @m, " \\\n\t\t$_";
2335         }
2336 #       push @m, map( " \\\n\t\t$_", @ARGV );
2337         push @m, "\n";
2338
2339         return join '', @m;
2340     }
2341
2342
2343
2344     my($cccmd, $linkcmd, $lperl);
2345
2346
2347     $cccmd = $self->const_cccmd($libperl);
2348     $cccmd =~ s/^CCCMD\s*=\s*//;
2349     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2350     $cccmd .= " $Config::Config{cccdlflags}"
2351         if ($Config::Config{useshrplib} eq 'true');
2352     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2353
2354     # The front matter of the linkcommand...
2355     $linkcmd = join ' ', "\$(CC)",
2356             grep($_, @Config{qw(large split ldflags ccdlflags)});
2357     $linkcmd =~ s/\s+/ /g;
2358     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2359
2360     # Which *.a files could we make use of...
2361     local(%static);
2362     require File::Find;
2363     File::Find::find(sub {
2364         return unless m/\Q$self->{LIB_EXT}\E$/;
2365         return if m/^libperl/;
2366         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2367         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2368
2369         if( exists $self->{INCLUDE_EXT} ){
2370                 my $found = 0;
2371                 my $incl;
2372                 my $xx;
2373
2374                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2375                 $xx =~ s,/?$_,,;
2376                 $xx =~ s,/,::,g;
2377
2378                 # Throw away anything not explicitly marked for inclusion.
2379                 # DynaLoader is implied.
2380                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2381                         if( $xx eq $incl ){
2382                                 $found++;
2383                                 last;
2384                         }
2385                 }
2386                 return unless $found;
2387         }
2388         elsif( exists $self->{EXCLUDE_EXT} ){
2389                 my $excl;
2390                 my $xx;
2391
2392                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2393                 $xx =~ s,/?$_,,;
2394                 $xx =~ s,/,::,g;
2395
2396                 # Throw away anything explicitly marked for exclusion
2397                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2398                         return if( $xx eq $excl );
2399                 }
2400         }
2401
2402         # don't include the installed version of this extension. I
2403         # leave this line here, although it is not necessary anymore:
2404         # I patched minimod.PL instead, so that Miniperl.pm won't
2405         # enclude duplicates
2406
2407         # Once the patch to minimod.PL is in the distribution, I can
2408         # drop it
2409         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2410         use Cwd 'cwd';
2411         $static{cwd() . "/" . $_}++;
2412     }, grep( -d $_, @{$searchdirs || []}) );
2413
2414     # We trust that what has been handed in as argument, will be buildable
2415     $static = [] unless $static;
2416     @static{@{$static}} = (1) x @{$static};
2417
2418     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2419     for (sort keys %static) {
2420         next unless /\Q$self->{LIB_EXT}\E$/;
2421         $_ = dirname($_) . "/extralibs.ld";
2422         push @$extra, $_;
2423     }
2424
2425     grep(s/^/-I/, @{$perlinc || []});
2426
2427     $target = "perl" unless $target;
2428     $tmp = "." unless $tmp;
2429
2430 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2431 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2432 # extralibs.all are computed correctly
2433     push @m, "
2434 MAP_LINKCMD   = $linkcmd
2435 MAP_PERLINC   = @{$perlinc || []}
2436 MAP_STATIC    = ",
2437 join(" \\\n\t", reverse sort keys %static), "
2438
2439 MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
2440 ";
2441
2442     if (defined $libperl) {
2443         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2444     }
2445     unless ($libperl && -f $lperl) { # Ilya's code...
2446         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2447         $libperl ||= "libperl$self->{LIB_EXT}";
2448         $libperl   = "$dir/$libperl";
2449         $lperl   ||= "libperl$self->{LIB_EXT}";
2450         $lperl     = "$dir/$lperl";
2451
2452         if (! -f $libperl and ! -f $lperl) {
2453           # We did not find a static libperl. Maybe there is a shared one?
2454           if ($^O eq 'solaris' or $^O eq 'sunos') {
2455             $lperl  = $libperl = "$dir/$Config::Config{libperl}";
2456             # SUNOS ld does not take the full path to a shared library
2457             $libperl = '' if $^O eq 'sunos';
2458           }
2459         }
2460
2461         print STDOUT "Warning: $libperl not found
2462     If you're going to build a static perl binary, make sure perl is installed
2463     otherwise ignore this warning\n"
2464                 unless (-f $lperl || defined($self->{PERL_SRC}));
2465     }
2466
2467     push @m, "
2468 MAP_LIBPERL = $libperl
2469 ";
2470
2471     push @m, "
2472 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2473         $self->{NOECHO}$self->{RM_F} \$\@
2474         $self->{NOECHO}\$(TOUCH) \$\@
2475 ";
2476
2477     my $catfile;
2478     foreach $catfile (@$extra){
2479         push @m, "\tcat $catfile >> \$\@\n";
2480     }
2481     # SUNOS ld does not take the full path to a shared library
2482     my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2483
2484     # Brain dead solaris linker does not use LD_RUN_PATH?
2485     # This fixes dynamic extensions which need shared libs
2486     my $ldfrom = ($^O eq 'solaris')?
2487            join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2488
2489 push @m, "
2490 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2491         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom \$(MAP_STATIC) $llibperl `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2492         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2493         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2494         $self->{NOECHO}echo 'To remove the intermediate files say'
2495         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2496
2497 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2498 ";
2499     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2500
2501     push @m, qq{
2502 $tmp/perlmain.c: $makefilename}, q{
2503         }.$self->{NOECHO}.q{echo Writing $@
2504         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2505                 -e "writemain(grep s#.*/auto/##, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2506
2507 };
2508     push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2509 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2510
2511
2512     push @m, q{
2513 doc_inst_perl:
2514         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2515         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2516         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2517                 "Perl binary" "$(MAP_TARGET)" \
2518                 MAP_STATIC "$(MAP_STATIC)" \
2519                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2520                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2521                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2522
2523 };
2524
2525     push @m, q{
2526 inst_perl: pure_inst_perl doc_inst_perl
2527
2528 pure_inst_perl: $(MAP_TARGET)
2529         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2530
2531 clean :: map_clean
2532
2533 map_clean :
2534         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2535 };
2536
2537     join '', @m;
2538 }
2539
2540 =item makefile (o)
2541
2542 Defines how to rewrite the Makefile.
2543
2544 =cut
2545
2546 sub makefile {
2547     my($self) = shift;
2548     my @m;
2549     # We do not know what target was originally specified so we
2550     # must force a manual rerun to be sure. But as it should only
2551     # happen very rarely it is not a significant problem.
2552     push @m, '
2553 $(OBJECT) : $(FIRST_MAKEFILE)
2554 ' if $self->{OBJECT};
2555
2556     push @m, q{
2557 # We take a very conservative approach here, but it\'s worth it.
2558 # We move Makefile to Makefile.old here to avoid gnu make looping.
2559 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2560         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2561         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2562         -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2563         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2564         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2565         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2566         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2567         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2568         false
2569
2570 # To change behavior to :: would be nice, but would break Tk b9.02
2571 # so you find such a warning below the dist target.
2572 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2573 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2574 };
2575
2576     join "", @m;
2577 }
2578
2579 =item manifypods (o)
2580
2581 Defines targets and routines to translate the pods into manpages and
2582 put them into the INST_* directories.
2583
2584 =cut
2585
2586 sub manifypods {
2587     my($self, %attribs) = @_;
2588     return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2589         %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2590     my($dist);
2591     my($pod2man_exe);
2592     if (defined $self->{PERL_SRC}) {
2593         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2594     } else {
2595         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2596     }
2597     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2598       # Maybe a build by uninstalled Perl?
2599       $pod2man_exe = $self->catfile($self->{PERL_INC}, "pod", "pod2man");
2600     }
2601     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2602         # No pod2man but some MAN3PODS to be installed
2603         print <<END;
2604
2605 Warning: I could not locate your pod2man program. Please make sure,
2606          your pod2man program is in your PATH before you execute 'make'
2607
2608 END
2609         $pod2man_exe = "-S pod2man";
2610     }
2611     my(@m);
2612     push @m,
2613 qq[POD2MAN_EXE = $pod2man_exe\n],
2614 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2615 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2616  $self->{MAKEFILE}, q[";' \\
2617 -e 'print "Manifying $$m{$$_}\n";' \\
2618 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2619 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2620 ];
2621     push @m, "\nmanifypods : pure_all ";
2622     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2623
2624     push(@m,"\n");
2625     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2626         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2627         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2628     }
2629     join('', @m);
2630 }
2631
2632 =item maybe_command
2633
2634 Returns true, if the argument is likely to be a command.
2635
2636 =cut
2637
2638 sub maybe_command {
2639     my($self,$file) = @_;
2640     return $file if -x $file && ! -d $file;
2641     return;
2642 }
2643
2644 =item maybe_command_in_dirs
2645
2646 method under development. Not yet used. Ask Ilya :-)
2647
2648 =cut
2649
2650 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2651 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2652     my($self, $names, $dirs, $trace, $ver) = @_;
2653     my($name, $dir);
2654     foreach $dir (@$dirs){
2655         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2656         foreach $name (@$names){
2657             my($abs,$tryabs);
2658             if ($self->file_name_is_absolute($name)) { # /foo/bar
2659                 $abs = $name;
2660             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2661                 $abs = $self->catfile($dir, $name);
2662             } else { # foo/bar
2663                 $abs = $self->catfile($self->curdir, $name);
2664             }
2665             print "Checking $abs for $name\n" if ($trace >= 2);
2666             next unless $tryabs = $self->maybe_command($abs);
2667             print "Substituting $tryabs instead of $abs\n"
2668                 if ($trace >= 2 and $tryabs ne $abs);
2669             $abs = $tryabs;
2670             if (defined $ver) {
2671                 print "Executing $abs\n" if ($trace >= 2);
2672                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2673                     print "Using PERL=$abs\n" if $trace;
2674                     return $abs;
2675                 }
2676             } else { # Do not look for perl
2677                 return $abs;
2678             }
2679         }
2680     }
2681 }
2682
2683 =item needs_linking (o)
2684
2685 Does this module need linking? Looks into subdirectory objects (see
2686 also has_link_code())
2687
2688 =cut
2689
2690 sub needs_linking {
2691     my($self) = shift;
2692     my($child,$caller);
2693     $caller = (caller(0))[3];
2694     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2695     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2696     if ($self->has_link_code or $self->{MAKEAPERL}){
2697         $self->{NEEDS_LINKING} = 1;
2698         return 1;
2699     }
2700     foreach $child (keys %{$self->{CHILDREN}}) {
2701         if ($self->{CHILDREN}->{$child}->needs_linking) {
2702             $self->{NEEDS_LINKING} = 1;
2703             return 1;
2704         }
2705     }
2706     return $self->{NEEDS_LINKING} = 0;
2707 }
2708
2709 =item nicetext
2710
2711 misnamed method (will have to be changed). The MM_Unix method just
2712 returns the argument without further processing.
2713
2714 On VMS used to insure that colons marking targets are preceded by
2715 space - most Unix Makes don't need this, but it's necessary under VMS
2716 to distinguish the target delimiter from a colon appearing as part of
2717 a filespec.
2718
2719 =cut
2720
2721 sub nicetext {
2722     my($self,$text) = @_;
2723     $text;
2724 }
2725
2726 =item parse_version
2727
2728 parse a file and return what you think is $VERSION in this file set to.
2729 It will return the string "undef" if it can't figure out what $VERSION
2730 is.
2731
2732 =cut
2733
2734 sub parse_version {
2735     my($self,$parsefile) = @_;
2736     my $result;
2737     local *FH;
2738     local $/ = "\n";
2739     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2740     my $inpod = 0;
2741     while (<FH>) {
2742         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2743         next if $inpod;
2744         chop;
2745         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2746         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2747         my $eval = qq{
2748             package ExtUtils::MakeMaker::_version;
2749             no strict;
2750
2751             local $1$2;
2752             \$$2=undef; do {
2753                 $_
2754             }; \$$2
2755         };
2756         local($^W) = 0;
2757         $result = eval($eval);
2758         warn "Could not eval '$eval' in $parsefile: $@" if $@;
2759         $result = "undef" unless defined $result;
2760         last;
2761     }
2762     close FH;
2763     return $result;
2764 }
2765
2766 =item parse_abstract
2767
2768 parse a file and return what you think is the ABSTRACT
2769
2770 =cut
2771
2772 sub parse_abstract {
2773     my($self,$parsefile) = @_;
2774     my $result;
2775     local *FH;
2776     local $/ = "\n";
2777     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2778     my $inpod = 0;
2779     my $package = $self->{DISTNAME};
2780     $package =~ s/-/::/g;
2781     while (<FH>) {
2782         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2783         next if !$inpod;
2784         chop;
2785         next unless /^($package\s-\s)(.*)/;
2786         $result = $2;
2787         last;
2788     }
2789     close FH;
2790     return $result;
2791 }
2792
2793 =item pasthru (o)
2794
2795 Defines the string that is passed to recursive make calls in
2796 subdirectories.
2797
2798 =cut
2799
2800 sub pasthru {
2801     my($self) = shift;
2802     my(@m,$key);
2803
2804     my(@pasthru);
2805     my($sep) = $Is_VMS ? ',' : '';
2806     $sep .= "\\\n\t";
2807
2808     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2809         push @pasthru, "$key=\"\$($key)\"";
2810     }
2811
2812     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2813     join "", @m;
2814 }
2815
2816 =item path
2817
2818 Takes no argument, returns the environment variable PATH as an array.
2819
2820 =cut
2821
2822 sub path {
2823     my($self) = @_;
2824     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2825     my $path = $ENV{PATH};
2826     $path =~ s:\\:/:g if $Is_OS2;
2827     my @path = split $path_sep, $path;
2828     foreach(@path) { $_ = '.' if $_ eq '' }
2829     @path;
2830 }
2831
2832 =item perl_script
2833
2834 Takes one argument, a file name, and returns the file name, if the
2835 argument is likely to be a perl script. On MM_Unix this is true for
2836 any ordinary, readable file.
2837
2838 =cut
2839
2840 sub perl_script {
2841     my($self,$file) = @_;
2842     return $file if -r $file && -f _;
2843     return;
2844 }
2845
2846 =item perldepend (o)
2847
2848 Defines the dependency from all *.h files that come with the perl
2849 distribution.
2850
2851 =cut
2852
2853 sub perldepend {
2854     my($self) = shift;
2855     my(@m);
2856     push @m, q{
2857 # Check for unpropogated config.sh changes. Should never happen.
2858 # We do NOT just update config.h because that is not sufficient.
2859 # An out of date config.h is not fatal but complains loudly!
2860 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2861         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2862
2863 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2864         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2865         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2866 } if $self->{PERL_SRC};
2867
2868     return join "", @m unless $self->needs_linking;
2869
2870     push @m, q{
2871 PERL_HDRS = \
2872 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2873 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2874 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2875 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2876 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2877 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2878 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2879 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2880 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h         $(PERL_INC)/iperlsys.h \
2881 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2882
2883 $(OBJECT) : $(PERL_HDRS)
2884 } if $self->{OBJECT};
2885
2886     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2887
2888     join "\n", @m;
2889 }
2890
2891 =item ppd
2892
2893 Defines target that creates a PPD (Perl Package Description) file
2894 for a binary distribution.
2895
2896 =cut
2897
2898 sub ppd {
2899     my($self) = @_;
2900     my(@m);
2901     if ($self->{ABSTRACT_FROM}){
2902         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2903             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2904     }
2905     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2906     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2907     push(@m, "ppd:\n");
2908     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2909     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2910     my $abstract = $self->{ABSTRACT};
2911     $abstract =~ s/\n/\\n/sg;
2912     $abstract =~ s/</&lt;/g;
2913     $abstract =~ s/>/&gt;/g;
2914     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2915     my ($author) = $self->{AUTHOR};
2916     $author =~ s/</&lt;/g;
2917     $author =~ s/>/&gt;/g;
2918     $author =~ s/@/\\@/g;
2919     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2920     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2921     my ($prereq);
2922     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2923         my $pre_req = $prereq;
2924         $pre_req =~ s/::/-/g;
2925         my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), (0) x 4) [0 .. 3];
2926         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" VERSION=\\\"$dep_ver\\\" />\\n}");
2927     }
2928     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
2929     push(@m, ". qq{\\t\\t<ARCHITECTURE NAME=\\\"$Config{'archname'}\\\" />\\n}");
2930     my ($bin_location) = $self->{BINARY_LOCATION};
2931     $bin_location =~ s/\\/\\\\/g;
2932     if ($self->{PPM_INSTALL_SCRIPT}) {
2933         if ($self->{PPM_INSTALL_EXEC}) {
2934             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2935         }
2936         else {
2937             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2938         }
2939     }
2940     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
2941     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
2942     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
2943
2944     join("", @m);
2945 }
2946
2947 =item perm_rw (o)
2948
2949 Returns the attribute C<PERM_RW> or the string C<644>.
2950 Used as the string that is passed
2951 to the C<chmod> command to set the permissions for read/writeable files.
2952 MakeMaker chooses C<644> because it has turned out in the past that
2953 relying on the umask provokes hard-to-track bug reports.
2954 When the return value is used by the perl function C<chmod>, it is
2955 interpreted as an octal value.
2956
2957 =cut
2958
2959 sub perm_rw {
2960     shift->{PERM_RW} || "644";
2961 }
2962
2963 =item perm_rwx (o)
2964
2965 Returns the attribute C<PERM_RWX> or the string C<755>,
2966 i.e. the string that is passed
2967 to the C<chmod> command to set the permissions for executable files.
2968 See also perl_rw.
2969
2970 =cut
2971
2972 sub perm_rwx {
2973     shift->{PERM_RWX} || "755";
2974 }
2975
2976 =item pm_to_blib
2977
2978 Defines target that copies all files in the hash PM to their
2979 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2980
2981 =cut
2982
2983 sub pm_to_blib {
2984     my $self = shift;
2985     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2986     return q{
2987 pm_to_blib: $(TO_INST_PM)
2988         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2989         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2990         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2991         }.$self->{NOECHO}.q{$(TOUCH) $@
2992 };
2993 }
2994
2995 =item post_constants (o)
2996
2997 Returns an empty string per default. Dedicated to overrides from
2998 within Makefile.PL after all constants have been defined.
2999
3000 =cut
3001
3002 sub post_constants{
3003     my($self) = shift;
3004     "";
3005 }
3006
3007 =item post_initialize (o)
3008
3009 Returns an empty string per default. Used in Makefile.PLs to add some
3010 chunk of text to the Makefile after the object is initialized.
3011
3012 =cut
3013
3014 sub post_initialize {
3015     my($self) = shift;
3016     "";
3017 }
3018
3019 =item postamble (o)
3020
3021 Returns an empty string. Can be used in Makefile.PLs to write some
3022 text to the Makefile at the end.
3023
3024 =cut
3025
3026 sub postamble {
3027     my($self) = shift;
3028     "";
3029 }
3030
3031 =item prefixify
3032
3033 Check a path variable in $self from %Config, if it contains a prefix,
3034 and replace it with another one.
3035
3036 Takes as arguments an attribute name, a search prefix and a
3037 replacement prefix. Changes the attribute in the object.
3038
3039 =cut
3040
3041 sub prefixify {
3042     my($self,$var,$sprefix,$rprefix) = @_;
3043     $self->{uc $var} ||= $Config{lc $var};
3044     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
3045     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
3046 }
3047
3048 =item processPL (o)
3049
3050 Defines targets to run *.PL files.
3051
3052 =cut
3053
3054 sub processPL {
3055     my($self) = shift;
3056     return "" unless $self->{PL_FILES};
3057     my(@m, $plfile);
3058     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3059         my $list = ref($self->{PL_FILES}->{$plfile})
3060                 ? $self->{PL_FILES}->{$plfile}
3061                 : [$self->{PL_FILES}->{$plfile}];
3062         foreach $target (@$list) {
3063         push @m, "
3064 all :: $target
3065         $self->{NOECHO}\$(NOOP)
3066
3067 $target :: $plfile
3068         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile $target
3069 ";
3070         }
3071     }
3072     join "", @m;
3073 }
3074
3075 =item realclean (o)
3076
3077 Defines the realclean target.
3078
3079 =cut
3080
3081 sub realclean {
3082     my($self, %attribs) = @_;
3083     my(@m);
3084     push(@m,'
3085 # Delete temporary files (via clean) and also delete installed files
3086 realclean purge ::  clean
3087 ');
3088     # realclean subdirectories first (already cleaned)
3089     my $sub = ($Is_Win32  &&  Win32::IsWin95()) ?
3090       "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3091       "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3092     foreach(@{$self->{DIR}}){
3093         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3094         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3095     }
3096     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3097     if( $self->has_link_code ){
3098         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3099         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
3100     }
3101     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n")
3102         if keys %{$self->{PM}};
3103     my(@otherfiles) = ($self->{MAKEFILE},
3104                        "$self->{MAKEFILE}.old"); # Makefiles last
3105     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3106     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
3107     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
3108     join("", @m);
3109 }
3110
3111 =item replace_manpage_separator
3112
3113 Takes the name of a package, which may be a nested package, in the
3114 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3115
3116 =cut
3117
3118 sub replace_manpage_separator {
3119     my($self,$man) = @_;
3120         if ($^O eq 'uwin') {
3121                 $man =~ s,/+,.,g;
3122         } else {
3123                 $man =~ s,/+,::,g;
3124         }
3125     $man;
3126 }
3127
3128 =item static (o)
3129
3130 Defines the static target.
3131
3132 =cut
3133
3134 sub static {
3135 # --- Static Loading Sections ---
3136
3137     my($self) = shift;
3138     '
3139 ## $(INST_PM) has been moved to the all: target.
3140 ## It remains here for awhile to allow for old usage: "make static"
3141 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3142 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3143         '.$self->{NOECHO}.'$(NOOP)
3144 ';
3145 }
3146
3147 =item static_lib (o)
3148
3149 Defines how to produce the *.a (or equivalent) files.
3150
3151 =cut
3152
3153 sub static_lib {
3154     my($self) = @_;
3155 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3156 #    return '' unless $self->needs_linking(); #might be because of a subdir
3157
3158     return '' unless $self->has_link_code;
3159
3160     my(@m);
3161     push(@m, <<'END');
3162 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3163         $(RM_RF) $@
3164 END
3165     # If this extension has it's own library (eg SDBM_File)
3166     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3167     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3168
3169     push @m,
3170 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
3171         $(CHMOD) $(PERM_RWX) $@
3172         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3173 };
3174     # Old mechanism - still available:
3175     push @m,
3176 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3177 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3178     push @m, "\n";
3179
3180     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3181     join('', "\n",@m);
3182 }
3183
3184 =item staticmake (o)
3185
3186 Calls makeaperl.
3187
3188 =cut
3189
3190 sub staticmake {
3191     my($self, %attribs) = @_;
3192     my(@static);
3193
3194     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3195
3196     # And as it's not yet built, we add the current extension
3197     # but only if it has some C code (or XS code, which implies C code)
3198     if (@{$self->{C}}) {
3199         @static = $self->catfile($self->{INST_ARCHLIB},
3200                                  "auto",
3201                                  $self->{FULLEXT},
3202                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3203                                 );
3204     }
3205
3206     # Either we determine now, which libraries we will produce in the
3207     # subdirectories or we do it at runtime of the make.
3208
3209     # We could ask all subdir objects, but I cannot imagine, why it
3210     # would be necessary.
3211
3212     # Instead we determine all libraries for the new perl at
3213     # runtime.
3214     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3215
3216     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3217                      DIRS       => \@searchdirs,
3218                      STAT       => \@static,
3219                      INCL       => \@perlinc,
3220                      TARGET     => $self->{MAP_TARGET},
3221                      TMP        => "",
3222                      LIBPERL    => $self->{LIBPERL_A}
3223                     );
3224 }
3225
3226 =item subdir_x (o)
3227
3228 Helper subroutine for subdirs
3229
3230 =cut
3231
3232 sub subdir_x {
3233     my($self, $subdir) = @_;
3234     my(@m);
3235     if ($Is_Win32 && Win32::IsWin95()) {
3236         return <<EOT;
3237 subdirs ::
3238         cd $subdir
3239         \$(MAKE) all \$(PASTHRU)
3240         cd ..
3241 EOT
3242     }
3243     else {
3244         return <<EOT;
3245
3246 subdirs ::
3247         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3248
3249 EOT
3250     }
3251 }
3252
3253 =item subdirs (o)
3254
3255 Defines targets to process subdirectories.
3256
3257 =cut
3258
3259 sub subdirs {
3260 # --- Sub-directory Sections ---
3261     my($self) = shift;
3262     my(@m,$dir);
3263     # This method provides a mechanism to automatically deal with
3264     # subdirectories containing further Makefile.PL scripts.
3265     # It calls the subdir_x() method for each subdirectory.
3266     foreach $dir (@{$self->{DIR}}){
3267         push(@m, $self->subdir_x($dir));
3268 ####    print "Including $dir subdirectory\n";
3269     }
3270     if (@m){
3271         unshift(@m, "
3272 # The default clean, realclean and test targets in this Makefile
3273 # have automatically been given entries for each subdir.
3274
3275 ");
3276     } else {
3277         push(@m, "\n# none")
3278     }
3279     join('',@m);
3280 }
3281
3282 =item test (o)
3283
3284 Defines the test targets.
3285
3286 =cut
3287
3288 sub test {
3289 # --- Test and Installation Sections ---
3290
3291     my($self, %attribs) = @_;
3292     my $tests = $attribs{TESTS};
3293     if (!$tests && -d 't') {
3294         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3295     }
3296     # note: 'test.pl' name is also hardcoded in init_dirscan()
3297     my(@m);
3298     push(@m,"
3299 TEST_VERBOSE=0
3300 TEST_TYPE=test_\$(LINKTYPE)
3301 TEST_FILE = test.pl
3302 TEST_FILES = $tests
3303 TESTDB_SW = -d
3304
3305 testdb :: testdb_\$(LINKTYPE)
3306
3307 test :: \$(TEST_TYPE)
3308 ");
3309     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3310                  @{$self->{DIR}}));
3311     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3312         unless $tests or -f "test.pl" or @{$self->{DIR}};
3313     push(@m, "\n");
3314
3315     push(@m, "test_dynamic :: pure_all\n");
3316     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3317     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3318     push(@m, "\n");
3319
3320     push(@m, "testdb_dynamic :: pure_all\n");
3321     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3322     push(@m, "\n");
3323
3324     # Occasionally we may face this degenerate target:
3325     push @m, "test_ : test_dynamic\n\n";
3326
3327     if ($self->needs_linking()) {
3328         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3329         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3330         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3331         push(@m, "\n");
3332         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3333         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3334         push(@m, "\n");
3335     } else {
3336         push @m, "test_static :: test_dynamic\n";
3337         push @m, "testdb_static :: testdb_dynamic\n";
3338     }
3339     join("", @m);
3340 }
3341
3342 =item test_via_harness (o)
3343
3344 Helper method to write the test targets
3345
3346 =cut
3347
3348 sub test_via_harness {
3349     my($self, $perl, $tests) = @_;
3350     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3351     "\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";
3352 }
3353
3354 =item test_via_script (o)
3355
3356 Other helper method for test.
3357
3358 =cut
3359
3360 sub test_via_script {
3361     my($self, $perl, $script) = @_;
3362     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3363     qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3364 };
3365 }
3366
3367 =item tool_autosplit (o)
3368
3369 Defines a simple perl call that runs autosplit. May be deprecated by
3370 pm_to_blib soon.
3371
3372 =cut
3373
3374 sub tool_autosplit {
3375 # --- Tool Sections ---
3376
3377     my($self, %attribs) = @_;
3378     my($asl) = "";
3379     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3380     q{
3381 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3382 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3383 };
3384 }
3385
3386 =item tools_other (o)
3387
3388 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3389 the Makefile. Also defines the perl programs MKPATH,
3390 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3391
3392 =cut
3393
3394 sub tools_other {
3395     my($self) = shift;
3396     my @m;
3397     my $bin_sh = $Config{sh} || '/bin/sh';
3398     push @m, qq{
3399 SHELL = $bin_sh
3400 };
3401
3402     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3403         push @m, "$_ = $self->{$_}\n";
3404     }
3405
3406     push @m, q{
3407 # The following is a portable way to say mkdir -p
3408 # To see which directories are created, change the if 0 to if 1
3409 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3410
3411 # This helps us to minimize the effect of the .exists files A yet
3412 # better solution would be to have a stable file in the perl
3413 # distribution with a timestamp of zero. But this solution doesn't
3414 # need any changes to the core distribution and works with older perls
3415 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3416 };
3417
3418
3419     return join "", @m if $self->{PARENT};
3420
3421     push @m, q{
3422 # Here we warn users that an old packlist file was found somewhere,
3423 # and that they should call some uninstall routine
3424 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3425 -e 'print "WARNING: I have found an old package in\n";' \\
3426 -e 'print "\t$$ARGV[0].\n";' \\
3427 -e 'print "Please make sure the two installations are not conflicting\n";'
3428
3429 UNINST=0
3430 VERBINST=1
3431
3432 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3433 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3434
3435 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3436 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3437 -e 'print "=over 4";' \
3438 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3439 -e 'print "=back";'
3440
3441 UNINSTALL =   $(PERL) -MExtUtils::Install \
3442 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3443 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3444 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3445 };
3446
3447     return join "", @m;
3448 }
3449
3450 =item tool_xsubpp (o)
3451
3452 Determines typemaps, xsubpp version, prototype behaviour.
3453
3454 =cut
3455
3456 sub tool_xsubpp {
3457     my($self) = shift;
3458     return "" unless $self->needs_linking;
3459     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3460     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3461     if( $self->{TYPEMAPS} ){
3462         my $typemap;
3463         foreach $typemap (@{$self->{TYPEMAPS}}){
3464                 if( ! -f  $typemap ){
3465                         warn "Typemap $typemap not found.\n";
3466                 }
3467                 else{
3468                         push(@tmdeps,  $typemap);
3469                 }
3470         }
3471     }
3472     push(@tmdeps, "typemap") if -f "typemap";
3473     my(@tmargs) = map("-typemap $_", @tmdeps);
3474     if( exists $self->{XSOPT} ){
3475         unshift( @tmargs, $self->{XSOPT} );
3476     }
3477
3478
3479     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3480
3481     # What are the correct thresholds for version 1 && 2 Paul?
3482     if ( $xsubpp_version > 1.923 ){
3483         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3484     } else {
3485         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3486             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3487         Your version of xsubpp is $xsubpp_version and cannot handle this.
3488         Please upgrade to a more recent version of xsubpp.
3489 };
3490         } else {
3491             $self->{XSPROTOARG} = "";
3492         }
3493     }
3494
3495     my $xsubpp = "xsubpp";
3496
3497     return qq{
3498 XSUBPPDIR = $xsdir
3499 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3500 XSPROTOARG = $self->{XSPROTOARG}
3501 XSUBPPDEPS = @tmdeps
3502 XSUBPPARGS = @tmargs
3503 };
3504 };
3505
3506 sub xsubpp_version
3507 {
3508     my($self,$xsubpp) = @_;
3509     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3510
3511     my ($version) ;
3512
3513     # try to figure out the version number of the xsubpp on the system
3514
3515     # first try the -v flag, introduced in 1.921 & 2.000a2
3516
3517     return "" unless $self->needs_linking;
3518
3519     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3520     print "Running $command\n" if $Verbose >= 2;
3521     $version = `$command` ;
3522     warn "Running '$command' exits with status " . ($?>>8) if $?;
3523     chop $version ;
3524
3525     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3526
3527     # nope, then try something else
3528
3529     my $counter = '000';
3530     my ($file) = 'temp' ;
3531     $counter++ while -e "$file$counter"; # don't overwrite anything
3532     $file .= $counter;
3533
3534     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3535     print F <<EOM ;
3536 MODULE = fred PACKAGE = fred
3537
3538 int
3539 fred(a)
3540         int     a;
3541 EOM
3542
3543     close F ;
3544
3545     $command = "$self->{PERL} $xsubpp $file 2>&1";
3546     print "Running $command\n" if $Verbose >= 2;
3547     my $text = `$command` ;
3548     warn "Running '$command' exits with status " . ($?>>8) if $?;
3549     unlink $file ;
3550
3551     # gets 1.2 -> 1.92 and 2.000a1
3552     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3553
3554     # it is either 1.0 or 1.1
3555     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3556
3557     # none of the above, so 1.0
3558     return $Xsubpp_Version = "1.0" ;
3559 }
3560
3561 =item top_targets (o)
3562
3563 Defines the targets all, subdirs, config, and O_FILES
3564
3565 =cut
3566
3567 sub top_targets {
3568 # --- Target Sections ---
3569
3570     my($self) = shift;
3571     my(@m);
3572     push @m, '
3573 #all :: config $(INST_PM) subdirs linkext manifypods
3574 ';
3575
3576     push @m, '
3577 all :: pure_all htmlifypods manifypods
3578         '.$self->{NOECHO}.'$(NOOP)
3579 '
3580           unless $self->{SKIPHASH}{'all'};
3581
3582     push @m, '
3583 pure_all :: config pm_to_blib subdirs linkext
3584         '.$self->{NOECHO}.'$(NOOP)
3585
3586 subdirs :: $(MYEXTLIB)
3587         '.$self->{NOECHO}.'$(NOOP)
3588
3589 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3590         '.$self->{NOECHO}.'$(NOOP)
3591
3592 config :: $(INST_ARCHAUTODIR)/.exists
3593         '.$self->{NOECHO}.'$(NOOP)
3594
3595 config :: $(INST_AUTODIR)/.exists
3596         '.$self->{NOECHO}.'$(NOOP)
3597 ';
3598
3599     push @m, qq{
3600 config :: Version_check
3601         $self->{NOECHO}\$(NOOP)
3602
3603 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3604
3605     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3606
3607     if (%{$self->{HTMLLIBPODS}}) {
3608         push @m, qq[
3609 config :: \$(INST_HTMLLIBDIR)/.exists
3610         $self->{NOECHO}\$(NOOP)
3611
3612 ];
3613         push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3614     }
3615
3616     if (%{$self->{HTMLSCRIPTPODS}}) {
3617         push @m, qq[
3618 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3619         $self->{NOECHO}\$(NOOP)
3620
3621 ];
3622         push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3623     }
3624
3625     if (%{$self->{MAN1PODS}}) {
3626         push @m, qq[
3627 config :: \$(INST_MAN1DIR)/.exists
3628         $self->{NOECHO}\$(NOOP)
3629
3630 ];
3631         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3632     }
3633     if (%{$self->{MAN3PODS}}) {
3634         push @m, qq[
3635 config :: \$(INST_MAN3DIR)/.exists
3636         $self->{NOECHO}\$(NOOP)
3637
3638 ];
3639         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3640     }
3641
3642     push @m, '
3643 $(O_FILES): $(H_FILES)
3644 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3645
3646     push @m, q{
3647 help:
3648         perldoc ExtUtils::MakeMaker
3649 };
3650
3651     push @m, q{
3652 Version_check:
3653         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3654                 -MExtUtils::MakeMaker=Version_check \
3655                 -e "Version_check('$(MM_VERSION)')"
3656 };
3657
3658     join('',@m);
3659 }
3660
3661 =item writedoc
3662
3663 Obsolete, deprecated method. Not used since Version 5.21.
3664
3665 =cut
3666
3667 sub writedoc {
3668 # --- perllocal.pod section ---
3669     my($self,$what,$name,@attribs)=@_;
3670     my $time = localtime;
3671     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3672     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3673     print "\n\n=back\n\n";
3674 }
3675
3676 =item xs_c (o)
3677
3678 Defines the suffix rules to compile XS files to C.
3679
3680 =cut
3681
3682 sub xs_c {
3683     my($self) = shift;
3684     return '' unless $self->needs_linking();
3685     '
3686 .xs.c:
3687         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3688 ';
3689 }
3690
3691 =item xs_cpp (o)
3692
3693 Defines the suffix rules to compile XS files to C++.
3694
3695 =cut
3696
3697 sub xs_cpp {
3698     my($self) = shift;
3699     return '' unless $self->needs_linking();
3700     '
3701 .xs.cpp:
3702         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3703 ';
3704 }
3705
3706 =item xs_o (o)
3707
3708 Defines suffix rules to go from XS to object files directly. This is
3709 only intended for broken make implementations.
3710
3711 =cut
3712
3713 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3714     my($self) = shift;
3715     return '' unless $self->needs_linking();
3716     '
3717 .xs$(OBJ_EXT):
3718         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3719         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3720 ';
3721 }
3722
3723 =item perl_archive
3724
3725 This is internal method that returns path to libperl.a equivalent
3726 to be linked to dynamic extensions. UNIX does not have one but OS2
3727 and Win32 do.
3728
3729 =cut
3730
3731 sub perl_archive
3732 {
3733  return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3734  return "";
3735 }
3736
3737 =item export_list
3738
3739 This is internal method that returns name of a file that is
3740 passed to linker to define symbols to be exported.
3741 UNIX does not have one but OS2 and Win32 do.
3742
3743 =cut
3744
3745 sub export_list
3746 {
3747  return "";
3748 }
3749
3750
3751 1;
3752
3753 =back
3754
3755 =head1 SEE ALSO
3756
3757 L<ExtUtils::MakeMaker>
3758
3759 =cut
3760
3761 __END__