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