lib/ExtUtils/MM_Unix.pm

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