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