lib/ExtUtils/MM_Unix.pm

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