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 =~ /\#/;
1171         next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1172         next unless $self->libscan($name);
1173         if (-d $name){
1174             next if -l $name; # We do not support symlinks at all
1175             $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1176         } elsif ($name =~ /\.xs$/){
1177             my($c); ($c = $name) =~ s/\.xs$/.c/;
1178             $xs{$name} = $c;
1179             $c{$c} = 1;
1180         } elsif ($name =~ /\.c(pp|xx|c)?$/i){  # .c .C .cpp .cxx .cc
1181             $c{$name} = 1
1182                 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1183         } elsif ($name =~ /\.h$/i){
1184             $h{$name} = 1;
1185         } elsif ($name =~ /\.(p[ml]|pod)$/){
1186             $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1187         } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
1188             ($pl_files{$name} = $name) =~ s/\.PL$// ;
1189         } elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
1190                  $name ne 'test.pl') {  # case-insensitive filesystem
1191             ($pl_files{$name} = $name) =~ s/\.pl$// ;
1192         }
1193     }
1194
1195     # Some larger extensions often wish to install a number of *.pm/pl
1196     # files into the library in various locations.
1197
1198     # The attribute PMLIBDIRS holds an array reference which lists
1199     # subdirectories which we should search for library files to
1200     # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
1201     # recursively search through the named directories (skipping any
1202     # which don't exist or contain Makefile.PL files).
1203
1204     # For each *.pm or *.pl file found $self->libscan() is called with
1205     # the default installation path in $_[1]. The return value of
1206     # libscan defines the actual installation location.  The default
1207     # libscan function simply returns the path.  The file is skipped
1208     # if libscan returns false.
1209
1210     # The default installation location passed to libscan in $_[1] is:
1211     #
1212     #  ./*.pm           => $(INST_LIBDIR)/*.pm
1213     #  ./xyz/...        => $(INST_LIBDIR)/xyz/...
1214     #  ./lib/...        => $(INST_LIB)/...
1215     #
1216     # In this way the 'lib' directory is seen as the root of the actual
1217     # perl library whereas the others are relative to INST_LIBDIR
1218     # (which includes PARENT_NAME). This is a subtle distinction but one
1219     # that's important for nested modules.
1220
1221     $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1222         unless $self->{PMLIBDIRS};
1223
1224     #only existing directories that aren't in $dir are allowed
1225
1226     # Avoid $_ wherever possible:
1227     # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1228     my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1229     my ($pmlibdir);
1230     @{$self->{PMLIBDIRS}} = ();
1231     foreach $pmlibdir (@pmlibdirs) {
1232         -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1233     }
1234
1235     if (@{$self->{PMLIBDIRS}}){
1236         print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1237             if ($Verbose >= 2);
1238         require File::Find;
1239         File::Find::find(sub {
1240             if (-d $_){
1241                 if ($_ eq "CVS" || $_ eq "RCS"){
1242                     $File::Find::prune = 1;
1243                 }
1244                 return;
1245             }
1246             return if /\#/;
1247             my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1248             my($striplibpath,$striplibname);
1249             $prefix =  '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1250             ($striplibname,$striplibpath) = fileparse($striplibpath);
1251             my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1252             local($_) = $inst; # for backwards compatibility
1253             $inst = $self->libscan($inst);
1254             print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1255             return unless $inst;
1256             $pm{$path} = $inst;
1257         }, @{$self->{PMLIBDIRS}});
1258     }
1259
1260     $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1261     $self->{XS}  = \%xs             unless $self->{XS};
1262     $self->{PM}  = \%pm             unless $self->{PM};
1263     $self->{C}   = [sort keys %c]   unless $self->{C};
1264     my(@o_files) = @{$self->{C}};
1265     $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
1266     $self->{H}   = [sort keys %h]   unless $self->{H};
1267     $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1268
1269     # Set up names of manual pages to generate from pods
1270     if ($self->{MAN1PODS}) {
1271     } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1272         $self->{MAN1PODS} = {};
1273     } else {
1274         my %manifypods = ();
1275         if ( exists $self->{EXE_FILES} ) {
1276             foreach $name (@{$self->{EXE_FILES}}) {
1277 #               use FileHandle ();
1278 #               my $fh = new FileHandle;
1279                 local *FH;
1280                 my($ispod)=0;
1281                 # one day test, if $/ can be set to '' safely (is the bug fixed that was in 5.001m?)
1282 #               if ($fh->open("<$name")) {
1283                 if (open(FH,"<$name")) {
1284 #                   while (<$fh>) {
1285                     while (<FH>) {
1286                         if (/^=head1\s+\w+/) {
1287                             $ispod=1;
1288                             last;
1289                         }
1290                     }
1291 #                   $fh->close;
1292                     close FH;
1293                 } else {
1294                     # If it doesn't exist yet, we assume, it has pods in it
1295                     $ispod = 1;
1296                 }
1297                 if( $ispod ) {
1298                     $manifypods{$name} = $self->catfile('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
1299                 }
1300             }
1301         }
1302         $self->{MAN1PODS} = \%manifypods;
1303     }
1304     if ($self->{MAN3PODS}) {
1305     } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1306         $self->{MAN3PODS} = {};
1307     } else {
1308         my %manifypods = (); # we collect the keys first, i.e. the files
1309                              # we have to convert to pod
1310         foreach $name (keys %{$self->{PM}}) {
1311             if ($name =~ /\.pod$/ ) {
1312                 $manifypods{$name} = $self->{PM}{$name};
1313             } elsif ($name =~ /\.p[ml]$/ ) {
1314 #               use FileHandle ();
1315 #               my $fh = new FileHandle;
1316                 local *FH;
1317                 my($ispod)=0;
1318 #               $fh->open("<$name");
1319                 if (open(FH,"<$name")) {
1320                     #           while (<$fh>) {
1321                     while (<FH>) {
1322                         if (/^=head1\s+\w+/) {
1323                             $ispod=1;
1324                             last;
1325                         }
1326                     }
1327                     #           $fh->close;
1328                     close FH;
1329                 } else {
1330                     $ispod = 1;
1331                 }
1332                 if( $ispod ) {
1333                     $manifypods{$name} = $self->{PM}{$name};
1334                 }
1335             }
1336         }
1337
1338         # Remove "Configure.pm" and similar, if it's not the only pod listed
1339         # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1340         foreach $name (keys %manifypods) {
1341             if ($name =~ /(config|setup).*\.pm/i) {
1342                 delete $manifypods{$name};
1343                 next;
1344             }
1345             my($manpagename) = $name;
1346             unless ($manpagename =~ s!^\W*lib\W+!!) { # everything below lib is ok
1347                 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1348             }
1349             $manpagename =~ s/\.p(od|m|l)$//;
1350             $manpagename = $self->replace_manpage_separator($manpagename);
1351             $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
1352         }
1353         $self->{MAN3PODS} = \%manifypods;
1354     }
1355 }
1356
1357 =item init_main
1358
1359 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1360 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1361 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1362 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1363
1364 =cut
1365
1366 sub init_main {
1367     my($self) = @_;
1368
1369     # --- Initialize Module Name and Paths
1370
1371     # NAME    = Foo::Bar::Oracle
1372     # FULLEXT = Foo/Bar/Oracle
1373     # BASEEXT = Oracle
1374     # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1375     # PARENT_NAME = Foo::Bar
1376 ### Only UNIX:
1377 ###    ($self->{FULLEXT} =
1378 ###     $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1379     $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1380
1381
1382     # Copied from DynaLoader:
1383
1384     my(@modparts) = split(/::/,$self->{NAME});
1385     my($modfname) = $modparts[-1];
1386
1387     # Some systems have restrictions on files names for DLL's etc.
1388     # mod2fname returns appropriate file base name (typically truncated)
1389     # It may also edit @modparts if required.
1390     if (defined &DynaLoader::mod2fname) {
1391         $modfname = &DynaLoader::mod2fname(\@modparts);
1392     }
1393
1394     ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!([\w:]+::)?(\w+)$! ;
1395
1396     if (defined &DynaLoader::mod2fname) {
1397         # As of 5.001m, dl_os2 appends '_'
1398         $self->{DLBASE} = $modfname;
1399     } else {
1400         $self->{DLBASE} = '$(BASEEXT)';
1401     }
1402
1403
1404     ### ROOTEXT deprecated from MM 5.32
1405 ###    ($self->{ROOTEXT} =
1406 ###     $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ;      #eg. /BSD/Foo
1407 ###    $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1408
1409
1410     # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1411
1412     # *Real* information: where did we get these two from? ...
1413     my $inc_config_dir = dirname($INC{'Config.pm'});
1414     my $inc_carp_dir   = dirname($INC{'Carp.pm'});
1415
1416     unless ($self->{PERL_SRC}){
1417         my($dir);
1418         foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir())){
1419             if (
1420                 -f $self->catfile($dir,"config.sh")
1421                 &&
1422                 -f $self->catfile($dir,"perl.h")
1423                 &&
1424                 -f $self->catfile($dir,"lib","Exporter.pm")
1425                ) {
1426                 $self->{PERL_SRC}=$dir ;
1427                 last;
1428             }
1429         }
1430     }
1431     if ($self->{PERL_SRC}){
1432         $self->{PERL_LIB}     ||= $self->catdir("$self->{PERL_SRC}","lib");
1433         $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1434         $self->{PERL_INC}     = $self->{PERL_SRC};
1435         # catch a situation that has occurred a few times in the past:
1436
1437         unless (
1438                 -s $self->catfile($self->{PERL_SRC},'cflags')
1439                 or
1440                 $Is_VMS
1441                 &&
1442                 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1443                 or
1444                 $Is_Mac
1445                ){
1446             warn qq{
1447 You cannot build extensions below the perl source tree after executing
1448 a 'make clean' in the perl source tree.
1449
1450 To rebuild extensions distributed with the perl source you should
1451 simply Configure (to include those extensions) and then build perl as
1452 normal. After installing perl the source tree can be deleted. It is
1453 not needed for building extensions by running 'perl Makefile.PL'
1454 usually without extra arguments.
1455
1456 It is recommended that you unpack and build additional extensions away
1457 from the perl source tree.
1458 };
1459         }
1460     } else {
1461         # we should also consider $ENV{PERL5LIB} here
1462         $self->{PERL_LIB}     ||= $Config::Config{privlibexp};
1463         $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1464         $self->{PERL_INC}     = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1465         my $perl_h;
1466         unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1467             die qq{
1468 Error: Unable to locate installed Perl libraries or Perl source code.
1469
1470 It is recommended that you install perl in a standard location before
1471 building extensions. Some precompiled versions of perl do not contain
1472 these header files, so you cannot build extensions. In such a case,
1473 please build and install your perl from a fresh perl distribution. It
1474 usually solves this kind of problem.
1475
1476 \(You get this message, because MakeMaker could not find "$perl_h"\)
1477 };
1478         }
1479 #        print STDOUT "Using header files found in $self->{PERL_INC}\n"
1480 #            if $Verbose && $self->needs_linking();
1481
1482     }
1483
1484     # We get SITELIBEXP and SITEARCHEXP directly via
1485     # Get_from_Config. When we are running standard modules, these
1486     # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1487     # set it to "site". I prefer that INSTALLDIRS be set from outside
1488     # MakeMaker.
1489     $self->{INSTALLDIRS} ||= "site";
1490
1491     # INST_LIB typically pre-set if building an extension after
1492     # perl has been built and installed. Setting INST_LIB allows
1493     # you to build directly into, say $Config::Config{privlibexp}.
1494     unless ($self->{INST_LIB}){
1495
1496
1497         ##### XXXXX We have to change this nonsense
1498
1499         if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1500             $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1501         } else {
1502             $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1503         }
1504     }
1505     $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1506     $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1507
1508     # We need to set up INST_LIBDIR before init_libscan() for VMS
1509     my @parentdir = split(/::/, $self->{PARENT_NAME});
1510     $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1511     $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1512     $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1513     $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1514
1515     # INST_EXE is deprecated, should go away March '97
1516     $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1517     $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1518
1519     # The user who requests an installation directory explicitly
1520     # should not have to tell us a architecture installation directory
1521     # as well. We look if a directory exists that is named after the
1522     # architecture. If not we take it as a sign that it should be the
1523     # same as the requested installation directory. Otherwise we take
1524     # the found one.
1525     # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1526     my($libpair);
1527     for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1528         my $lib = "install$libpair->{l}";
1529         my $Lib = uc $lib;
1530         my $Arch = uc "install$libpair->{a}";
1531         if( $self->{$Lib} && ! $self->{$Arch} ){
1532             my($ilib) = $Config{$lib};
1533             $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1534
1535             $self->prefixify($Arch,$ilib,$self->{$Lib});
1536
1537             unless (-d $self->{$Arch}) {
1538                 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1539                 $self->{$Arch} = $self->{$Lib};
1540             }
1541             print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1542         }
1543     }
1544
1545     # we have to look at the relation between $Config{prefix} and the
1546     # requested values. We're going to set the $Config{prefix} part of
1547     # all the installation path variables to literally $(PREFIX), so
1548     # the user can still say make PREFIX=foo
1549     my($configure_prefix) = $Config{'prefix'};
1550     $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1551     $self->{PREFIX} ||= $configure_prefix;
1552
1553
1554     my($install_variable,$search_prefix,$replace_prefix);
1555
1556     # The rule, taken from Configure, is that if prefix contains perl,
1557     # we shape the tree
1558     #    perlprefix/lib/                INSTALLPRIVLIB
1559     #    perlprefix/lib/pod/
1560     #    perlprefix/lib/site_perl/      INSTALLSITELIB
1561     #    perlprefix/bin/                INSTALLBIN
1562     #    perlprefix/man/                INSTALLMAN1DIR
1563     # else
1564     #    prefix/lib/perl5/              INSTALLPRIVLIB
1565     #    prefix/lib/perl5/pod/
1566     #    prefix/lib/perl5/site_perl/    INSTALLSITELIB
1567     #    prefix/bin/                    INSTALLBIN
1568     #    prefix/lib/perl5/man/          INSTALLMAN1DIR
1569
1570     $replace_prefix = qq[\$\(PREFIX\)];
1571     for $install_variable (qw/
1572                            INSTALLBIN
1573                            INSTALLSCRIPT
1574                            /) {
1575         $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1576     }
1577     $search_prefix = $configure_prefix =~ /perl/ ?
1578         $self->catdir($configure_prefix,"lib") :
1579         $self->catdir($configure_prefix,"lib","perl5");
1580     if ($self->{LIB}) {
1581         $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1582         $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1583             $self->catdir($self->{LIB},$Config{'archname'});
1584     } else {
1585         $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1586             $self->catdir(qq[\$\(PREFIX\)],"lib") :
1587                 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5");
1588         for $install_variable (qw/
1589                                INSTALLPRIVLIB
1590                                INSTALLARCHLIB
1591                                INSTALLSITELIB
1592                                INSTALLSITEARCH
1593                                /) {
1594             $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1595         }
1596     }
1597     $search_prefix = $configure_prefix =~ /perl/ ?
1598         $self->catdir($configure_prefix,"man") :
1599             $self->catdir($configure_prefix,"lib","perl5","man");
1600     $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1601         $self->catdir(qq[\$\(PREFIX\)],"man") :
1602             $self->catdir(qq[\$\(PREFIX\)],"lib","perl5","man");
1603     for $install_variable (qw/
1604                            INSTALLMAN1DIR
1605                            INSTALLMAN3DIR
1606                            /) {
1607         $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1608     }
1609
1610     # Now we head at the manpages. Maybe they DO NOT want manpages
1611     # installed
1612     $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1613         unless defined $self->{INSTALLMAN1DIR};
1614     unless (defined $self->{INST_MAN1DIR}){
1615         if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1616             $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1617         } else {
1618             $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1619         }
1620     }
1621     $self->{MAN1EXT} ||= $Config::Config{man1ext};
1622
1623     $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1624         unless defined $self->{INSTALLMAN3DIR};
1625     unless (defined $self->{INST_MAN3DIR}){
1626         if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1627             $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1628         } else {
1629             $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1630         }
1631     }
1632     $self->{MAN3EXT} ||= $Config::Config{man3ext};
1633
1634
1635     # Get some stuff out of %Config if we haven't yet done so
1636     print STDOUT "CONFIG must be an array ref\n"
1637         if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1638     $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1639     push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1640     push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1641     my(%once_only,$m);
1642     foreach $m (@{$self->{CONFIG}}){
1643         next if $once_only{$m};
1644         print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1645                 unless exists $Config::Config{$m};
1646         $self->{uc $m} ||= $Config::Config{$m};
1647         $once_only{$m} = 1;
1648     }
1649
1650 # This is too dangerous:
1651 #    if ($^O eq "next") {
1652 #       $self->{AR} = "libtool";
1653 #       $self->{AR_STATIC_ARGS} = "-o";
1654 #    }
1655 # But I leave it as a placeholder
1656
1657     $self->{AR_STATIC_ARGS} ||= "cr";
1658
1659     # These should never be needed
1660     $self->{LD} ||= 'ld';
1661     $self->{OBJ_EXT} ||= '.o';
1662     $self->{LIB_EXT} ||= '.a';
1663
1664     $self->{MAP_TARGET} ||= "perl";
1665
1666     $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1667
1668     # make a simple check if we find Exporter
1669     warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1670         (Exporter.pm not found)"
1671         unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1672         $self->{NAME} eq "ExtUtils::MakeMaker";
1673
1674     # Determine VERSION and VERSION_FROM
1675     ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1676     if ($self->{VERSION_FROM}){
1677         $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1678             Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1679     }
1680
1681     # strip blanks
1682     if ($self->{VERSION}) {
1683         $self->{VERSION} =~ s/^\s+//;
1684         $self->{VERSION} =~ s/\s+$//;
1685     }
1686
1687     $self->{VERSION} ||= "0.10";
1688     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1689
1690
1691     # Graham Barr and Paul Marquess had some ideas how to ensure
1692     # version compatibility between the *.pm file and the
1693     # corresponding *.xs file. The bottomline was, that we need an
1694     # XS_VERSION macro that defaults to VERSION:
1695     $self->{XS_VERSION} ||= $self->{VERSION};
1696
1697     # --- Initialize Perl Binary Locations
1698
1699     # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1700     # will be working versions of perl 5. miniperl has priority over perl
1701     # for PERL to ensure that $(PERL) is usable while building ./ext/*
1702     my ($component,@defpath);
1703     foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1704         push @defpath, $component if defined $component;
1705     }
1706     $self->{PERL} ||=
1707         $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1708             \@defpath, $Verbose );
1709     # don't check if perl is executable, maybe they have decided to
1710     # supply switches with perl
1711
1712     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1713     ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1714         unless ($self->{FULLPERL});
1715 }
1716
1717 =item init_others
1718
1719 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1720 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1721 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1722
1723 =cut
1724
1725 sub init_others {       # --- Initialize Other Attributes
1726     my($self) = shift;
1727
1728     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1729     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1730     # undefined. In any case we turn it into an anon array:
1731
1732     # May check $Config{libs} too, thus not empty.
1733     $self->{LIBS}=[''] unless $self->{LIBS};
1734
1735     $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1736     $self->{LD_RUN_PATH} = "";
1737     my($libs);
1738     foreach $libs ( @{$self->{LIBS}} ){
1739         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1740         my(@libs) = $self->extliblist($libs);
1741         if ($libs[0] or $libs[1] or $libs[2]){
1742             # LD_RUN_PATH now computed by ExtUtils::Liblist
1743             ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1744             last;
1745         }
1746     }
1747
1748     if ( $self->{OBJECT} ) {
1749         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1750     } else {
1751         # init_dirscan should have found out, if we have C files
1752         $self->{OBJECT} = "";
1753         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1754     }
1755     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1756     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1757     $self->{PERLMAINCC} ||= '$(CC)';
1758     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1759
1760     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1761     # the 'dynamic' section of MM.  We don't have this problem with
1762     # 'static', since we either must use it (%Config says we can't
1763     # use dynamic loading) or the caller asked for it explicitly.
1764     if (!$self->{LINKTYPE}) {
1765        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1766                         ? 'static'
1767                         : ($Config::Config{usedl} ? 'dynamic' : 'static');
1768     };
1769
1770     # These get overridden for VMS and maybe some other systems
1771     $self->{NOOP}  ||= '$(SHELL) -c true';
1772     $self->{FIRST_MAKEFILE} ||= "Makefile";
1773     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1774     $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1775     $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1776     $self->{RM_F}  ||= "rm -f";
1777     $self->{RM_RF} ||= "rm -rf";
1778     $self->{TOUCH} ||= "touch";
1779     $self->{TEST_F} ||= "test -f";
1780     $self->{CP} ||= "cp";
1781     $self->{MV} ||= "mv";
1782     $self->{CHMOD} ||= "chmod";
1783     $self->{UMASK_NULL} ||= "umask 0";
1784     $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1785 }
1786
1787 =item install (o)
1788
1789 Defines the install target.
1790
1791 =cut
1792
1793 sub install {
1794     my($self, %attribs) = @_;
1795     my(@m);
1796
1797     push @m, q{
1798 install :: all pure_install doc_install
1799
1800 install_perl :: all pure_perl_install doc_perl_install
1801
1802 install_site :: all pure_site_install doc_site_install
1803
1804 install_ :: install_site
1805         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1806
1807 pure_install :: pure_$(INSTALLDIRS)_install
1808
1809 doc_install :: doc_$(INSTALLDIRS)_install
1810         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
1811
1812 pure__install : pure_site_install
1813         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1814
1815 doc__install : doc_site_install
1816         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1817
1818 pure_perl_install ::
1819         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1820                 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1821                 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1822                 $(INST_LIB) $(INSTALLPRIVLIB) \
1823                 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
1824                 $(INST_BIN) $(INSTALLBIN) \
1825                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1826                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1827                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1828         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1829                 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
1830
1831
1832 pure_site_install ::
1833         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1834                 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
1835                 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
1836                 $(INST_LIB) $(INSTALLSITELIB) \
1837                 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
1838                 $(INST_BIN) $(INSTALLBIN) \
1839                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1840                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1841                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1842         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1843                 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
1844
1845 doc_perl_install ::
1846         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1847                 "Module" "$(NAME)" \
1848                 "installed into" "$(INSTALLPRIVLIB)" \
1849                 LINKTYPE "$(LINKTYPE)" \
1850                 VERSION "$(VERSION)" \
1851                 EXE_FILES "$(EXE_FILES)" \
1852                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1853
1854 doc_site_install ::
1855         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1856                 "Module" "$(NAME)" \
1857                 "installed into" "$(INSTALLSITELIB)" \
1858                 LINKTYPE "$(LINKTYPE)" \
1859                 VERSION "$(VERSION)" \
1860                 EXE_FILES "$(EXE_FILES)" \
1861                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1862
1863 };
1864
1865     push @m, q{
1866 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
1867
1868 uninstall_from_perldirs ::
1869         }.$self->{NOECHO}.
1870         q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
1871
1872 uninstall_from_sitedirs ::
1873         }.$self->{NOECHO}.
1874         q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
1875 };
1876
1877     join("",@m);
1878 }
1879
1880 =item installbin (o)
1881
1882 Defines targets to install EXE_FILES.
1883
1884 =cut
1885
1886 sub installbin {
1887     my($self) = shift;
1888     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
1889     return "" unless @{$self->{EXE_FILES}};
1890     my(@m, $from, $to, %fromto, @to);
1891     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
1892     for $from (@{$self->{EXE_FILES}}) {
1893         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
1894         local($_) = $path; # for backwards compatibility
1895         $to = $self->libscan($path);
1896         print "libscan($from) => '$to'\n" if ($Verbose >=2);
1897         $fromto{$from}=$to;
1898     }
1899     @to   = values %fromto;
1900     push(@m, "
1901 EXE_FILES = @{$self->{EXE_FILES}}
1902
1903 all :: @to
1904
1905 realclean ::
1906         $self->{RM_F} @to
1907 ");
1908
1909     while (($from,$to) = each %fromto) {
1910         last unless defined $from;
1911         my $todir = dirname($to);
1912         push @m, "
1913 $to: $from $self->{MAKEFILE} $todir/.exists
1914         $self->{NOECHO}$self->{RM_F} $to
1915         $self->{CP} $from $to
1916 ";
1917     }
1918     join "", @m;
1919 }
1920
1921 =item libscan (o)
1922
1923 Takes a path to a file that is found by init_dirscan and returns false
1924 if we don't want to include this file in the library. Mainly used to
1925 exclude RCS, CVS, and SCCS directories from installation.
1926
1927 =cut
1928
1929 # ';
1930
1931 sub libscan {
1932     my($self,$path) = @_;
1933     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
1934     $path;
1935 }
1936
1937 =item linkext (o)
1938
1939 Defines the linkext target which in turn defines the LINKTYPE.
1940
1941 =cut
1942
1943 sub linkext {
1944     my($self, %attribs) = @_;
1945     # LINKTYPE => static or dynamic or ''
1946     my($linktype) = defined $attribs{LINKTYPE} ?
1947       $attribs{LINKTYPE} : '$(LINKTYPE)';
1948     "
1949 linkext :: $linktype
1950         $self->{NOECHO}\$(NOOP)
1951 ";
1952 }
1953
1954 =item lsdir
1955
1956 Takes as arguments a directory name and a regular expression. Returns
1957 all entries in the directory that match the regular expression.
1958
1959 =cut
1960
1961 sub lsdir {
1962     my($self) = shift;
1963     my($dir, $regex) = @_;
1964     my(@ls);
1965     my $dh = new DirHandle;
1966     $dh->open($dir || ".") or return ();
1967     @ls = $dh->read;
1968     $dh->close;
1969     @ls = grep(/$regex/, @ls) if $regex;
1970     @ls;
1971 }
1972
1973 =item macro (o)
1974
1975 Simple subroutine to insert the macros defined by the macro attribute
1976 into the Makefile.
1977
1978 =cut
1979
1980 sub macro {
1981     my($self,%attribs) = @_;
1982     my(@m,$key,$val);
1983     while (($key,$val) = each %attribs){
1984         last unless defined $key;
1985         push @m, "$key = $val\n";
1986     }
1987     join "", @m;
1988 }
1989
1990 =item makeaperl (o)
1991
1992 Called by staticmake. Defines how to write the Makefile to produce a
1993 static new perl.
1994
1995 By default the Makefile produced includes all the static extensions in
1996 the perl library. (Purified versions of library files, e.g.,
1997 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
1998
1999 =cut
2000
2001 sub makeaperl {
2002     my($self, %attribs) = @_;
2003     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2004         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2005     my(@m);
2006     push @m, "
2007 # --- MakeMaker makeaperl section ---
2008 MAP_TARGET    = $target
2009 FULLPERL      = $self->{FULLPERL}
2010 ";
2011     return join '', @m if $self->{PARENT};
2012
2013     my($dir) = join ":", @{$self->{DIR}};
2014
2015     unless ($self->{MAKEAPERL}) {
2016         push @m, q{
2017 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2018         $(MAKE) -f $(MAKE_APERL_FILE) $@
2019
2020 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2021         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2022         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2023                 Makefile.PL DIR=}, $dir, q{ \
2024                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2025                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2026
2027         foreach (@ARGV){
2028                 if( /\s/ ){
2029                         s/=(.*)/='$1'/;
2030                 }
2031                 push @m, " \\\n\t\t$_";
2032         }
2033 #       push @m, map( " \\\n\t\t$_", @ARGV );
2034         push @m, "\n";
2035
2036         return join '', @m;
2037     }
2038
2039
2040
2041     my($cccmd, $linkcmd, $lperl);
2042
2043
2044     $cccmd = $self->const_cccmd($libperl);
2045     $cccmd =~ s/^CCCMD\s*=\s*//;
2046     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2047     $cccmd .= " $Config::Config{cccdlflags}"
2048         if ($Config::Config{useshrplib} eq 'true');
2049     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2050
2051     # The front matter of the linkcommand...
2052     $linkcmd = join ' ', "\$(CC)",
2053             grep($_, @Config{qw(large split ldflags ccdlflags)});
2054     $linkcmd =~ s/\s+/ /g;
2055     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2056
2057     # Which *.a files could we make use of...
2058     local(%static);
2059     require File::Find;
2060     File::Find::find(sub {
2061         return unless m/\Q$self->{LIB_EXT}\E$/;
2062         return if m/^libperl/;
2063         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2064         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2065
2066         if( exists $self->{INCLUDE_EXT} ){
2067                 my $found = 0;
2068                 my $incl;
2069                 my $xx;
2070
2071                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2072                 $xx =~ s,/?$_,,;
2073                 $xx =~ s,/,::,g;
2074
2075                 # Throw away anything not explicitly marked for inclusion.
2076                 # DynaLoader is implied.
2077                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2078                         if( $xx eq $incl ){
2079                                 $found++;
2080                                 last;
2081                         }
2082                 }
2083                 return unless $found;
2084         }
2085         elsif( exists $self->{EXCLUDE_EXT} ){
2086                 my $excl;
2087                 my $xx;
2088
2089                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2090                 $xx =~ s,/?$_,,;
2091                 $xx =~ s,/,::,g;
2092
2093                 # Throw away anything explicitly marked for exclusion
2094                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2095                         return if( $xx eq $excl );
2096                 }
2097         }
2098
2099         # don't include the installed version of this extension. I
2100         # leave this line here, although it is not necessary anymore:
2101         # I patched minimod.PL instead, so that Miniperl.pm won't
2102         # enclude duplicates
2103
2104         # Once the patch to minimod.PL is in the distribution, I can
2105         # drop it
2106         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2107         use Cwd 'cwd';
2108         $static{cwd() . "/" . $_}++;
2109     }, grep( -d $_, @{$searchdirs || []}) );
2110
2111     # We trust that what has been handed in as argument, will be buildable
2112     $static = [] unless $static;
2113     @static{@{$static}} = (1) x @{$static};
2114
2115     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2116     for (sort keys %static) {
2117         next unless /\Q$self->{LIB_EXT}\E$/;
2118         $_ = dirname($_) . "/extralibs.ld";
2119         push @$extra, $_;
2120     }
2121
2122     grep(s/^/-I/, @{$perlinc || []});
2123
2124     $target = "perl" unless $target;
2125     $tmp = "." unless $tmp;
2126
2127 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2128 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2129 # extralibs.all are computed correctly
2130     push @m, "
2131 MAP_LINKCMD   = $linkcmd
2132 MAP_PERLINC   = @{$perlinc || []}
2133 MAP_STATIC    = ",
2134 join(" \\\n\t", reverse sort keys %static), "
2135
2136 MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
2137 ";
2138
2139     if (defined $libperl) {
2140         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2141     }
2142     unless ($libperl && -f $lperl) { # Ilya's code...
2143         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2144         $libperl ||= "libperl$self->{LIB_EXT}";
2145         $libperl   = "$dir/$libperl";
2146         $lperl   ||= "libperl$self->{LIB_EXT}";
2147         $lperl     = "$dir/$lperl";
2148
2149         if (! -f $libperl and ! -f $lperl) {
2150           # We did not find a static libperl. Maybe there is a shared one?
2151           if ($^O eq 'solaris' or $^O eq 'sunos') {
2152             $lperl  = $libperl = "$dir/$Config::Config{libperl}";
2153             # SUNOS ld does not take the full path to a shared library
2154             $libperl = '' if $^O eq 'sunos';
2155           }
2156         }
2157
2158         print STDOUT "Warning: $libperl not found
2159     If you're going to build a static perl binary, make sure perl is installed
2160     otherwise ignore this warning\n"
2161                 unless (-f $lperl || defined($self->{PERL_SRC}));
2162     }
2163
2164     push @m, "
2165 MAP_LIBPERL = $libperl
2166 ";
2167
2168     push @m, "
2169 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2170         $self->{NOECHO}$self->{RM_F} \$\@
2171         $self->{NOECHO}\$(TOUCH) \$\@
2172 ";
2173
2174     my $catfile;
2175     foreach $catfile (@$extra){
2176         push @m, "\tcat $catfile >> \$\@\n";
2177     }
2178     # SUNOS ld does not take the full path to a shared library
2179     my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2180
2181     # Brain dead solaris linker does not use LD_RUN_PATH?
2182     # This fixes dynamic extensions which need shared libs
2183     my $ldfrom = ($^O eq 'solaris')?
2184            join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2185
2186 push @m, "
2187 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2188         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom $llibperl \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2189         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2190         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2191         $self->{NOECHO}echo 'To remove the intermediate files say'
2192         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2193
2194 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2195 ";
2196     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2197
2198     push @m, qq{
2199 $tmp/perlmain.c: $makefilename}, q{
2200         }.$self->{NOECHO}.q{echo Writing $@
2201         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2202                 -e "writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)" > $@t && $(MV) $@t $@
2203
2204 };
2205
2206     push @m, q{
2207 doc_inst_perl:
2208         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2209         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2210                 "Perl binary" "$(MAP_TARGET)" \
2211                 MAP_STATIC "$(MAP_STATIC)" \
2212                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2213                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2214                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2215
2216 };
2217
2218     push @m, q{
2219 inst_perl: pure_inst_perl doc_inst_perl
2220
2221 pure_inst_perl: $(MAP_TARGET)
2222         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2223
2224 clean :: map_clean
2225
2226 map_clean :
2227         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2228 };
2229
2230     join '', @m;
2231 }
2232
2233 =item makefile (o)
2234
2235 Defines how to rewrite the Makefile.
2236
2237 =cut
2238
2239 sub makefile {
2240     my($self) = shift;
2241     my @m;
2242     # We do not know what target was originally specified so we
2243     # must force a manual rerun to be sure. But as it should only
2244     # happen very rarely it is not a significant problem.
2245     push @m, '
2246 $(OBJECT) : $(FIRST_MAKEFILE)
2247 ' if $self->{OBJECT};
2248
2249     push @m, q{
2250 # We take a very conservative approach here, but it\'s worth it.
2251 # We move Makefile to Makefile.old here to avoid gnu make looping.
2252 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2253         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2254         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2255         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2256         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2257         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2258         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2259         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2260         false
2261
2262 # To change behavior to :: would be nice, but would break Tk b9.02
2263 # so you find such a warning below the dist target.
2264 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2265 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2266 };
2267
2268     join "", @m;
2269 }
2270
2271 =item manifypods (o)
2272
2273 Defines targets and routines to translate the pods into manpages and
2274 put them into the INST_* directories.
2275
2276 =cut
2277
2278 sub manifypods {
2279     my($self, %attribs) = @_;
2280     return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2281     my($dist);
2282     my($pod2man_exe);
2283     if (defined $self->{PERL_SRC}) {
2284         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2285     } else {
2286         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2287     }
2288     unless ($self->perl_script($pod2man_exe)) {
2289         # No pod2man but some MAN3PODS to be installed
2290         print <<END;
2291
2292 Warning: I could not locate your pod2man program. Please make sure,
2293          your pod2man program is in your PATH before you execute 'make'
2294
2295 END
2296         $pod2man_exe = "-S pod2man";
2297     }
2298     my(@m);
2299     push @m,
2300 qq[POD2MAN_EXE = $pod2man_exe\n],
2301 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2302 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2303 -e 'print "Manifying $$m{$$_}\n";' \\
2304 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2305 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2306 ];
2307     push @m, "\nmanifypods : ";
2308     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2309
2310     push(@m,"\n");
2311     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2312         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2313         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2314     }
2315     join('', @m);
2316 }
2317
2318 =item maybe_command
2319
2320 Returns true, if the argument is likely to be a command.
2321
2322 =cut
2323
2324 sub maybe_command {
2325     my($self,$file) = @_;
2326     return $file if -x $file && ! -d $file;
2327     return;
2328 }
2329
2330 =item maybe_command_in_dirs
2331
2332 method under development. Not yet used. Ask Ilya :-)
2333
2334 =cut
2335
2336 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2337 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2338     my($self, $names, $dirs, $trace, $ver) = @_;
2339     my($name, $dir);
2340     foreach $dir (@$dirs){
2341         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2342         foreach $name (@$names){
2343             my($abs,$tryabs);
2344             if ($self->file_name_is_absolute($name)) { # /foo/bar
2345                 $abs = $name;
2346             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2347                 $abs = $self->catfile($dir, $name);
2348             } else { # foo/bar
2349                 $abs = $self->catfile($self->curdir, $name);
2350             }
2351             print "Checking $abs for $name\n" if ($trace >= 2);
2352             next unless $tryabs = $self->maybe_command($abs);
2353             print "Substituting $tryabs instead of $abs\n"
2354                 if ($trace >= 2 and $tryabs ne $abs);
2355             $abs = $tryabs;
2356             if (defined $ver) {
2357                 print "Executing $abs\n" if ($trace >= 2);
2358                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2359                     print "Using PERL=$abs\n" if $trace;
2360                     return $abs;
2361                 }
2362             } else { # Do not look for perl
2363                 return $abs;
2364             }
2365         }
2366     }
2367 }
2368
2369 =item needs_linking (o)
2370
2371 Does this module need linking? Looks into subdirectory objects (see
2372 also has_link_code())
2373
2374 =cut
2375
2376 sub needs_linking {
2377     my($self) = shift;
2378     my($child,$caller);
2379     $caller = (caller(0))[3];
2380     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2381     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2382     if ($self->has_link_code or $self->{MAKEAPERL}){
2383         $self->{NEEDS_LINKING} = 1;
2384         return 1;
2385     }
2386     foreach $child (keys %{$self->{CHILDREN}}) {
2387         if ($self->{CHILDREN}->{$child}->needs_linking) {
2388             $self->{NEEDS_LINKING} = 1;
2389             return 1;
2390         }
2391     }
2392     return $self->{NEEDS_LINKING} = 0;
2393 }
2394
2395 =item nicetext
2396
2397 misnamed method (will have to be changed). The MM_Unix method just
2398 returns the argument without further processing.
2399
2400 On VMS used to insure that colons marking targets are preceded by
2401 space - most Unix Makes don't need this, but it's necessary under VMS
2402 to distinguish the target delimiter from a colon appearing as part of
2403 a filespec.
2404
2405 =cut
2406
2407 sub nicetext {
2408     my($self,$text) = @_;
2409     $text;
2410 }
2411
2412 =item parse_version
2413
2414 parse a file and return what you think is $VERSION in this file set to
2415
2416 =cut
2417
2418 sub parse_version {
2419     my($self,$parsefile) = @_;
2420     my $result;
2421     local *FH;
2422     local $/ = "\n";
2423     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2424     my $inpod = 0;
2425     while (<FH>) {
2426         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2427         next if $inpod;
2428         chop;
2429         next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2430         my $eval = qq{
2431             package ExtUtils::MakeMaker::_version;
2432             no strict;
2433
2434             \$$1=undef; do {
2435                 $_
2436             }; \$$1
2437         };
2438         local($^W) = 0;
2439         $result = eval($eval) || 0;
2440         die "Could not eval '$eval' in $parsefile: $@" if $@;
2441         last;
2442     }
2443     close FH;
2444     return $result;
2445 }
2446
2447
2448 =item pasthru (o)
2449
2450 Defines the string that is passed to recursive make calls in
2451 subdirectories.
2452
2453 =cut
2454
2455 sub pasthru {
2456     my($self) = shift;
2457     my(@m,$key);
2458
2459     my(@pasthru);
2460     my($sep) = $Is_VMS ? ',' : '';
2461     $sep .= "\\\n\t";
2462
2463     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2464         push @pasthru, "$key=\"\$($key)\"";
2465     }
2466
2467     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2468     join "", @m;
2469 }
2470
2471 =item path
2472
2473 Takes no argument, returns the environment variable PATH as an array.
2474
2475 =cut
2476
2477 sub path {
2478     my($self) = @_;
2479     my $path_sep = $Is_OS2 ? ";" : ":";
2480     my $path = $ENV{PATH};
2481     $path =~ s:\\:/:g if $Is_OS2;
2482     my @path = split $path_sep, $path;
2483     foreach(@path) { $_ = '.' if $_ eq '' }
2484     @path;
2485 }
2486
2487 =item perl_script
2488
2489 Takes one argument, a file name, and returns the file name, if the
2490 argument is likely to be a perl script. On MM_Unix this is true for
2491 any ordinary, readable file.
2492
2493 =cut
2494
2495 sub perl_script {
2496     my($self,$file) = @_;
2497     return $file if -r $file && -f _;
2498     return;
2499 }
2500
2501 =item perldepend (o)
2502
2503 Defines the dependency from all *.h files that come with the perl
2504 distribution.
2505
2506 =cut
2507
2508 sub perldepend {
2509     my($self) = shift;
2510     my(@m);
2511     push @m, q{
2512 # Check for unpropogated config.sh changes. Should never happen.
2513 # We do NOT just update config.h because that is not sufficient.
2514 # An out of date config.h is not fatal but complains loudly!
2515 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2516         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2517
2518 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2519         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2520         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2521 } if $self->{PERL_SRC};
2522
2523     return join "", @m unless $self->needs_linking;
2524
2525     push @m, q{
2526 PERL_HDRS = \
2527 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2528 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2529 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2530 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2531 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2532 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2533 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2534 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2535 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h                                \
2536 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2537
2538 $(OBJECT) : $(PERL_HDRS)
2539 } if $self->{OBJECT};
2540
2541     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2542
2543     join "\n", @m;
2544 }
2545
2546 =item pm_to_blib
2547
2548 Defines target that copies all files in the hash PM to their
2549 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2550
2551 =cut
2552
2553 sub pm_to_blib {
2554     my $self = shift;
2555     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2556     return q{
2557 pm_to_blib: $(TO_INST_PM)
2558         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2559         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2560         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2561         }.$self->{NOECHO}.q{$(TOUCH) $@
2562 };
2563 }
2564
2565 =item post_constants (o)
2566
2567 Returns an empty string per default. Dedicated to overrides from
2568 within Makefile.PL after all constants have been defined.
2569
2570 =cut
2571
2572 sub post_constants{
2573     my($self) = shift;
2574     "";
2575 }
2576
2577 =item post_initialize (o)
2578
2579 Returns an empty string per default. Used in Makefile.PLs to add some
2580 chunk of text to the Makefile after the object is initialized.
2581
2582 =cut
2583
2584 sub post_initialize {
2585     my($self) = shift;
2586     "";
2587 }
2588
2589 =item postamble (o)
2590
2591 Returns an empty string. Can be used in Makefile.PLs to write some
2592 text to the Makefile at the end.
2593
2594 =cut
2595
2596 sub postamble {
2597     my($self) = shift;
2598     "";
2599 }
2600
2601 =item prefixify
2602
2603 Check a path variable in $self from %Config, if it contains a prefix,
2604 and replace it with another one.
2605
2606 Takes as arguments an attribute name, a search prefix and a
2607 replacement prefix. Changes the attribute in the object.
2608
2609 =cut
2610
2611 sub prefixify {
2612     my($self,$var,$sprefix,$rprefix) = @_;
2613     $self->{uc $var} ||= $Config{lc $var};
2614     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2615     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2616 }
2617
2618 =item processPL (o)
2619
2620 Defines targets to run *.PL files.
2621
2622 =cut
2623
2624 sub processPL {
2625     my($self) = shift;
2626     return "" unless $self->{PL_FILES};
2627     my(@m, $plfile);
2628     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2629         push @m, "
2630 all :: $self->{PL_FILES}->{$plfile}
2631
2632 $self->{PL_FILES}->{$plfile} :: $plfile
2633         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2634 ";
2635     }
2636     join "", @m;
2637 }
2638
2639 =item realclean (o)
2640
2641 Defines the realclean target.
2642
2643 =cut
2644
2645 sub realclean {
2646     my($self, %attribs) = @_;
2647     my(@m);
2648     push(@m,'
2649 # Delete temporary files (via clean) and also delete installed files
2650 realclean purge ::  clean
2651 ');
2652     # realclean subdirectories first (already cleaned)
2653     my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2654     foreach(@{$self->{DIR}}){
2655         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2656         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2657     }
2658     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2659     if( $self->has_link_code ){
2660         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2661         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
2662     }
2663     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
2664     my(@otherfiles) = ($self->{MAKEFILE},
2665                        "$self->{MAKEFILE}.old"); # Makefiles last
2666     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2667     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2668     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2669     join("", @m);
2670 }
2671
2672 =item replace_manpage_separator
2673
2674 Takes the name of a package, which may be a nested package, in the
2675 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2676
2677 =cut
2678
2679 sub replace_manpage_separator {
2680     my($self,$man) = @_;
2681     $man =~ s,/+,::,g;
2682     $man;
2683 }
2684
2685 =item static (o)
2686
2687 Defines the static target.
2688
2689 =cut
2690
2691 sub static {
2692 # --- Static Loading Sections ---
2693
2694     my($self) = shift;
2695     '
2696 ## $(INST_PM) has been moved to the all: target.
2697 ## It remains here for awhile to allow for old usage: "make static"
2698 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2699 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2700         '.$self->{NOECHO}.'$(NOOP)
2701 ';
2702 }
2703
2704 =item static_lib (o)
2705
2706 Defines how to produce the *.a (or equivalent) files.
2707
2708 =cut
2709
2710 sub static_lib {
2711     my($self) = @_;
2712 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2713 #    return '' unless $self->needs_linking(); #might be because of a subdir
2714
2715     return '' unless $self->has_link_code;
2716
2717     my(@m);
2718     push(@m, <<'END');
2719 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2720         $(RM_RF) $@
2721 END
2722     # If this extension has it's own library (eg SDBM_File)
2723     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2724     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2725
2726     push @m,
2727 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2728         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2729         $(CHMOD) 755 $@
2730 };
2731
2732 # Old mechanism - still available:
2733
2734     push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
2735         if $self->{PERL_SRC};
2736
2737     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2738     join('', "\n",@m);
2739 }
2740
2741 =item staticmake (o)
2742
2743 Calls makeaperl.
2744
2745 =cut
2746
2747 sub staticmake {
2748     my($self, %attribs) = @_;
2749     my(@static);
2750
2751     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
2752
2753     # And as it's not yet built, we add the current extension
2754     # but only if it has some C code (or XS code, which implies C code)
2755     if (@{$self->{C}}) {
2756         @static = $self->catfile($self->{INST_ARCHLIB},
2757                                  "auto",
2758                                  $self->{FULLEXT},
2759                                  "$self->{BASEEXT}$self->{LIB_EXT}"
2760                                 );
2761     }
2762
2763     # Either we determine now, which libraries we will produce in the
2764     # subdirectories or we do it at runtime of the make.
2765
2766     # We could ask all subdir objects, but I cannot imagine, why it
2767     # would be necessary.
2768
2769     # Instead we determine all libraries for the new perl at
2770     # runtime.
2771     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2772
2773     $self->makeaperl(MAKE       => $self->{MAKEFILE},
2774                      DIRS       => \@searchdirs,
2775                      STAT       => \@static,
2776                      INCL       => \@perlinc,
2777                      TARGET     => $self->{MAP_TARGET},
2778                      TMP        => "",
2779                      LIBPERL    => $self->{LIBPERL_A}
2780                     );
2781 }
2782
2783 =item subdir_x (o)
2784
2785 Helper subroutine for subdirs
2786
2787 =cut
2788
2789 sub subdir_x {
2790     my($self, $subdir) = @_;
2791     my(@m);
2792     qq{
2793
2794 subdirs ::
2795         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
2796
2797 };
2798 }
2799
2800 =item subdirs (o)
2801
2802 Defines targets to process subdirectories.
2803
2804 =cut
2805
2806 sub subdirs {
2807 # --- Sub-directory Sections ---
2808     my($self) = shift;
2809     my(@m,$dir);
2810     # This method provides a mechanism to automatically deal with
2811     # subdirectories containing further Makefile.PL scripts.
2812     # It calls the subdir_x() method for each subdirectory.
2813     foreach $dir (@{$self->{DIR}}){
2814         push(@m, $self->subdir_x($dir));
2815 ####    print "Including $dir subdirectory\n";
2816     }
2817     if (@m){
2818         unshift(@m, "
2819 # The default clean, realclean and test targets in this Makefile
2820 # have automatically been given entries for each subdir.
2821
2822 ");
2823     } else {
2824         push(@m, "\n# none")
2825     }
2826     join('',@m);
2827 }
2828
2829 =item test (o)
2830
2831 Defines the test targets.
2832
2833 =cut
2834
2835 sub test {
2836 # --- Test and Installation Sections ---
2837
2838     my($self, %attribs) = @_;
2839     my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2840     my(@m);
2841     push(@m,"
2842 TEST_VERBOSE=0
2843 TEST_TYPE=test_\$(LINKTYPE)
2844 TEST_FILE = test.pl
2845 TESTDB_SW = -d
2846
2847 testdb :: testdb_\$(LINKTYPE)
2848
2849 test :: \$(TEST_TYPE)
2850 ");
2851     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2852                  @{$self->{DIR}}));
2853     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
2854         unless $tests or -f "test.pl" or @{$self->{DIR}};
2855     push(@m, "\n");
2856
2857     push(@m, "test_dynamic :: pure_all\n");
2858     push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2859     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2860     push(@m, "\n");
2861
2862     push(@m, "testdb_dynamic :: pure_all\n");
2863     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
2864     push(@m, "\n");
2865
2866     # Occasionally we may face this degenerate target:
2867     push @m, "test_ : test_dynamic\n\n";
2868
2869     if ($self->needs_linking()) {
2870         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
2871         push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2872         push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2873         push(@m, "\n");
2874         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
2875         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
2876         push(@m, "\n");
2877     } else {
2878         push @m, "test_static :: test_dynamic\n";
2879         push @m, "testdb_static :: testdb_dynamic\n";
2880     }
2881     join("", @m);
2882 }
2883
2884 =item test_via_harness (o)
2885
2886 Helper method to write the test targets
2887
2888 =cut
2889
2890 sub test_via_harness {
2891     my($self, $perl, $tests) = @_;
2892     "\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";
2893 }
2894
2895 =item test_via_script (o)
2896
2897 Other helper method for test.
2898
2899 =cut
2900
2901 sub test_via_script {
2902     my($self, $perl, $script) = @_;
2903     qq{\tPERL_DL_NONLAZY=1 $perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
2904 };
2905 }
2906
2907 =item tool_autosplit (o)
2908
2909 Defines a simple perl call that runs autosplit. May be deprecated by
2910 pm_to_blib soon.
2911
2912 =cut
2913
2914 sub tool_autosplit {
2915 # --- Tool Sections ---
2916
2917     my($self, %attribs) = @_;
2918     my($asl) = "";
2919     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
2920     q{
2921 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
2922 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
2923 };
2924 }
2925
2926 =item tools_other (o)
2927
2928 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
2929 the Makefile. Also defines the perl programs MKPATH,
2930 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
2931
2932 =cut
2933
2934 sub tools_other {
2935     my($self) = shift;
2936     my @m;
2937     my $bin_sh = $Config{sh} || '/bin/sh';
2938     push @m, qq{
2939 SHELL = $bin_sh
2940 };
2941
2942     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
2943         push @m, "$_ = $self->{$_}\n";
2944     }
2945
2946     push @m, q{
2947 # The following is a portable way to say mkdir -p
2948 # To see which directories are created, change the if 0 to if 1
2949 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
2950
2951 # This helps us to minimize the effect of the .exists files A yet
2952 # better solution would be to have a stable file in the perl
2953 # distribution with a timestamp of zero. But this solution doesn't
2954 # need any changes to the core distribution and works with older perls
2955 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
2956 };
2957
2958
2959     return join "", @m if $self->{PARENT};
2960
2961     push @m, q{
2962 # Here we warn users that an old packlist file was found somewhere,
2963 # and that they should call some uninstall routine
2964 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
2965 -e 'print "WARNING: I have found an old package in\n";' \\
2966 -e 'print "\t$$ARGV[0].\n";' \\
2967 -e 'print "Please make sure the two installations are not conflicting\n";'
2968
2969 UNINST=0
2970 VERBINST=1
2971
2972 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
2973 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
2974
2975 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
2976 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
2977 -e 'print "=over 4";' \
2978 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
2979 -e 'print "=back";'
2980
2981 UNINSTALL =   $(PERL) -MExtUtils::Install \
2982 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
2983 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
2984 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
2985 };
2986
2987     return join "", @m;
2988 }
2989
2990 =item tool_xsubpp (o)
2991
2992 Determines typemaps, xsubpp version, prototype behaviour.
2993
2994 =cut
2995
2996 sub tool_xsubpp {
2997     my($self) = shift;
2998     return "" unless $self->needs_linking;
2999     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3000     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3001     if( $self->{TYPEMAPS} ){
3002         my $typemap;
3003         foreach $typemap (@{$self->{TYPEMAPS}}){
3004                 if( ! -f  $typemap ){
3005                         warn "Typemap $typemap not found.\n";
3006                 }
3007                 else{
3008                         push(@tmdeps,  $typemap);
3009                 }
3010         }
3011     }
3012     push(@tmdeps, "typemap") if -f "typemap";
3013     my(@tmargs) = map("-typemap $_", @tmdeps);
3014     if( exists $self->{XSOPT} ){
3015         unshift( @tmargs, $self->{XSOPT} );
3016     }
3017
3018
3019     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3020
3021     # What are the correct thresholds for version 1 && 2 Paul?
3022     if ( $xsubpp_version > 1.923 ){
3023         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3024     } else {
3025         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3026             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3027         Your version of xsubpp is $xsubpp_version and cannot handle this.
3028         Please upgrade to a more recent version of xsubpp.
3029 };
3030         } else {
3031             $self->{XSPROTOARG} = "";
3032         }
3033     }
3034
3035     return qq{
3036 XSUBPPDIR = $xsdir
3037 XSUBPP = \$(XSUBPPDIR)/xsubpp
3038 XSPROTOARG = $self->{XSPROTOARG}
3039 XSUBPPDEPS = @tmdeps
3040 XSUBPPARGS = @tmargs
3041 };
3042 };
3043
3044 sub xsubpp_version
3045 {
3046     my($self,$xsubpp) = @_;
3047     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3048
3049     my ($version) ;
3050
3051     # try to figure out the version number of the xsubpp on the system
3052
3053     # first try the -v flag, introduced in 1.921 & 2.000a2
3054
3055     return "" unless $self->needs_linking;
3056
3057     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3058     print "Running $command\n" if $Verbose >= 2;
3059     $version = `$command` ;
3060     warn "Running '$command' exits with status " . ($?>>8) if $?;
3061     chop $version ;
3062
3063     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3064
3065     # nope, then try something else
3066
3067     my $counter = '000';
3068     my ($file) = 'temp' ;
3069     $counter++ while -e "$file$counter"; # don't overwrite anything
3070     $file .= $counter;
3071
3072     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3073     print F <<EOM ;
3074 MODULE = fred PACKAGE = fred
3075
3076 int
3077 fred(a)
3078         int     a;
3079 EOM
3080
3081     close F ;
3082
3083     $command = "$self->{PERL} $xsubpp $file 2>&1";
3084     print "Running $command\n" if $Verbose >= 2;
3085     my $text = `$command` ;
3086     warn "Running '$command' exits with status " . ($?>>8) if $?;
3087     unlink $file ;
3088
3089     # gets 1.2 -> 1.92 and 2.000a1
3090     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3091
3092     # it is either 1.0 or 1.1
3093     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3094
3095     # none of the above, so 1.0
3096     return $Xsubpp_Version = "1.0" ;
3097 }
3098
3099 =item top_targets (o)
3100
3101 Defines the targets all, subdirs, config, and O_FILES
3102
3103 =cut
3104
3105 sub top_targets {
3106 # --- Target Sections ---
3107
3108     my($self) = shift;
3109     my(@m);
3110     push @m, '
3111 #all :: config $(INST_PM) subdirs linkext manifypods
3112 ';
3113
3114     push @m, '
3115 all :: pure_all manifypods
3116         '.$self->{NOECHO}.'$(NOOP)
3117 '
3118           unless $self->{SKIPHASH}{'all'};
3119
3120     push @m, '
3121 pure_all :: config pm_to_blib subdirs linkext
3122         '.$self->{NOECHO}.'$(NOOP)
3123
3124 subdirs :: $(MYEXTLIB)
3125         '.$self->{NOECHO}.'$(NOOP)
3126
3127 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3128         '.$self->{NOECHO}.'$(NOOP)
3129
3130 config :: $(INST_ARCHAUTODIR)/.exists
3131         '.$self->{NOECHO}.'$(NOOP)
3132
3133 config :: $(INST_AUTODIR)/.exists
3134         '.$self->{NOECHO}.'$(NOOP)
3135 ';
3136
3137     push @m, qq{
3138 config :: Version_check
3139         $self->{NOECHO}\$(NOOP)
3140
3141 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3142
3143     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3144
3145     if (%{$self->{MAN1PODS}}) {
3146         push @m, qq[
3147 config :: \$(INST_MAN1DIR)/.exists
3148         $self->{NOECHO}\$(NOOP)
3149
3150 ];
3151         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3152     }
3153     if (%{$self->{MAN3PODS}}) {
3154         push @m, qq[
3155 config :: \$(INST_MAN3DIR)/.exists
3156         $self->{NOECHO}\$(NOOP)
3157
3158 ];
3159         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3160     }
3161
3162     push @m, '
3163 $(O_FILES): $(H_FILES)
3164 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3165
3166     push @m, q{
3167 help:
3168         perldoc ExtUtils::MakeMaker
3169 };
3170
3171     push @m, q{
3172 Version_check:
3173         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3174                 -MExtUtils::MakeMaker=Version_check \
3175                 -e "Version_check('$(MM_VERSION)')"
3176 };
3177
3178     join('',@m);
3179 }
3180
3181 =item writedoc
3182
3183 Obsolete, depecated method. Not used since Version 5.21.
3184
3185 =cut
3186
3187 sub writedoc {
3188 # --- perllocal.pod section ---
3189     my($self,$what,$name,@attribs)=@_;
3190     my $time = localtime;
3191     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3192     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3193     print "\n\n=back\n\n";
3194 }
3195
3196 =item xs_c (o)
3197
3198 Defines the suffix rules to compile XS files to C.
3199
3200 =cut
3201
3202 sub xs_c {
3203     my($self) = shift;
3204     return '' unless $self->needs_linking();
3205     '
3206 .xs.c:
3207         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3208 ';
3209 }
3210
3211 =item xs_o (o)
3212
3213 Defines suffix rules to go from XS to object files directly. This is
3214 only intended for broken make implementations.
3215
3216 =cut
3217
3218 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3219     my($self) = shift;
3220     return '' unless $self->needs_linking();
3221     '
3222 .xs$(OBJ_EXT):
3223         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3224         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3225 ';
3226 }
3227
3228 =item perl_archive
3229
3230 This is internal method that returns path to libperl.a equivalent
3231 to be linked to dynamic extensions. UNIX does not have one but OS2
3232 and Win32 do.
3233
3234 =cut
3235
3236 sub perl_archive
3237 {
3238  return "";
3239 }
3240
3241 =item export_list
3242
3243 This is internal method that returns name of a file that is
3244 passed to linker to define symbols to be exported.
3245 UNIX does not have one but OS2 and Win32 do.
3246
3247 =cut
3248
3249 sub export_list
3250 {
3251  return "";
3252 }
3253
3254
3255 1;
3256
3257 =back
3258
3259 =head1 SEE ALSO
3260
3261 L<ExtUtils::MakeMaker>
3262
3263 =cut
3264
3265 __END__