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