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