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