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