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.113 $, 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::extliblist ;
 180 sub ExtUtils::MM_Unix::file_name_is_absolute ;
 181 sub ExtUtils::MM_Unix::find_perl ;
 182 sub ExtUtils::MM_Unix::force ;
 183 sub ExtUtils::MM_Unix::guess_name ;
 184 sub ExtUtils::MM_Unix::has_link_code ;
 185 sub ExtUtils::MM_Unix::init_dirscan ;
 186 sub ExtUtils::MM_Unix::init_main ;
 187 sub ExtUtils::MM_Unix::init_others ;
 188 sub ExtUtils::MM_Unix::install ;
 189 sub ExtUtils::MM_Unix::installbin ;
 190 sub ExtUtils::MM_Unix::libscan ;
 191 sub ExtUtils::MM_Unix::linkext ;
 192 sub ExtUtils::MM_Unix::lsdir ;
 193 sub ExtUtils::MM_Unix::macro ;
 194 sub ExtUtils::MM_Unix::makeaperl ;
 195 sub ExtUtils::MM_Unix::makefile ;
 196 sub ExtUtils::MM_Unix::manifypods ;
 197 sub ExtUtils::MM_Unix::maybe_command ;
 198 sub ExtUtils::MM_Unix::maybe_command_in_dirs ;
 199 sub ExtUtils::MM_Unix::needs_linking ;
 200 sub ExtUtils::MM_Unix::nicetext ;
 201 sub ExtUtils::MM_Unix::parse_version ;
 202 sub ExtUtils::MM_Unix::pasthru ;
 203 sub ExtUtils::MM_Unix::path ;
 204 sub ExtUtils::MM_Unix::perl_script ;
 205 sub ExtUtils::MM_Unix::perldepend ;
 206 sub ExtUtils::MM_Unix::pm_to_blib ;
 207 sub ExtUtils::MM_Unix::post_constants ;
 208 sub ExtUtils::MM_Unix::post_initialize ;
 209 sub ExtUtils::MM_Unix::postamble ;
 210 sub ExtUtils::MM_Unix::prefixify ;
 211 sub ExtUtils::MM_Unix::processPL ;
 212 sub ExtUtils::MM_Unix::realclean ;
 213 sub ExtUtils::MM_Unix::replace_manpage_separator ;
 214 sub ExtUtils::MM_Unix::static ;
 215 sub ExtUtils::MM_Unix::static_lib ;
 216 sub ExtUtils::MM_Unix::staticmake ;
 217 sub ExtUtils::MM_Unix::subdir_x ;
 218 sub ExtUtils::MM_Unix::subdirs ;
 219 sub ExtUtils::MM_Unix::test ;
 220 sub ExtUtils::MM_Unix::test_via_harness ;
 221 sub ExtUtils::MM_Unix::test_via_script ;
 222 sub ExtUtils::MM_Unix::tool_autosplit ;
 223 sub ExtUtils::MM_Unix::tool_xsubpp ;
 224 sub ExtUtils::MM_Unix::tools_other ;
 225 sub ExtUtils::MM_Unix::top_targets ;
 226 sub ExtUtils::MM_Unix::writedoc ;
 227 sub ExtUtils::MM_Unix::xs_c ;
 228 sub ExtUtils::MM_Unix::xs_o ;
 229 sub ExtUtils::MM_Unix::xsubpp_version ;
 230
 231 package ExtUtils::MM_Unix;
 232
 233 use SelfLoader;
 234
 235 1;
 236
 237 __DATA__
 238
 239 =back
 240
 241 =head2 SelfLoaded methods
 242
 243 =over 2
 244
 245 =item c_o (o)
 246
 247 Defines the suffix rules to compile different flavors of C files to
 248 object files.
 249
 250 =cut
 251
 252 sub c_o {
 253 # --- Translation Sections ---
 254
 255     my($self) = shift;
 256     return '' unless $self->needs_linking();
 257     my(@m);
 258     push @m, '
 259 .c$(OBJ_EXT):
 260         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
 261 ';
 262     push @m, '
 263 .C$(OBJ_EXT):
 264         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
 265 ' if $^O ne 'os2';                      # Case-specific
 266     push @m, '
 267 .cpp$(OBJ_EXT):
 268         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
 269
 270 .cxx$(OBJ_EXT):
 271         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
 272
 273 .cc$(OBJ_EXT):
 274         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
 275 ';
 276     join "", @m;
 277 }
 278
 279 =item cflags (o)
 280
 281 Does very much the same as the cflags script in the perl
 282 distribution. It doesn't return the whole compiler command line, but
 283 initializes all of its parts. The const_cccmd method then actually
 284 returns the definition of the CCCMD macro which uses these parts.
 285
 286 =cut
 287
 288 #'
 289
 290 sub cflags {
 291     my($self,$libperl)=@_;
 292     return $self->{CFLAGS} if $self->{CFLAGS};
 293     return '' unless $self->needs_linking();
 294
 295     my($prog, $uc, $perltype, %cflags);
 296     $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
 297     $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
 298
 299     @cflags{qw(cc ccflags optimize large split shellflags)}
 300         = @Config{qw(cc ccflags optimize large split shellflags)};
 301     my($optdebug) = "";
 302
 303     $cflags{shellflags} ||= '';
 304
 305     my(%map) =  (
 306                 D =>   '-DDEBUGGING',
 307                 E =>   '-DEMBED',
 308                 DE =>  '-DDEBUGGING -DEMBED',
 309                 M =>   '-DEMBED -DMULTIPLICITY',
 310                 DM =>  '-DDEBUGGING -DEMBED -DMULTIPLICITY',
 311                 );
 312
 313     if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
 314         $uc = uc($1);
 315     } else {
 316         $uc = ""; # avoid warning
 317     }
 318     $perltype = $map{$uc} ? $map{$uc} : "";
 319
 320     if ($uc =~ /^D/) {
 321         $optdebug = "-g";
 322     }
 323
 324
 325     my($name);
 326     ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
 327     if ($prog = $Config::Config{$name}) {
 328         # Expand hints for this extension via the shell
 329         print STDOUT "Processing $name hint:\n" if $Verbose;
 330         my(@o)=`cc=\"$cflags{cc}\"
 331           ccflags=\"$cflags{ccflags}\"
 332           optimize=\"$cflags{optimize}\"
 333           perltype=\"$cflags{perltype}\"
 334           optdebug=\"$cflags{optdebug}\"
 335           large=\"$cflags{large}\"
 336           split=\"$cflags{'split'}\"
 337           eval '$prog'
 338           echo cc=\$cc
 339           echo ccflags=\$ccflags
 340           echo optimize=\$optimize
 341           echo perltype=\$perltype
 342           echo optdebug=\$optdebug
 343           echo large=\$large
 344           echo split=\$split
 345           `;
 346         my($line);
 347         foreach $line (@o){
 348             chomp $line;
 349             if ($line =~ /(.*?)=\s*(.*)\s*$/){
 350                 $cflags{$1} = $2;
 351                 print STDOUT "  $1 = $2\n" if $Verbose;
 352             } else {
 353                 print STDOUT "Unrecognised result from hint: '$line'\n";
 354             }
 355         }
 356     }
 357
 358     if ($optdebug) {
 359         $cflags{optimize} = $optdebug;
 360     }
 361
 362     for (qw(ccflags optimize perltype large split)) {
 363         $cflags{$_} =~ s/^\s+//;
 364         $cflags{$_} =~ s/\s+/ /g;
 365         $cflags{$_} =~ s/\s+$//;
 366         $self->{uc $_} ||= $cflags{$_}
 367     }
 368
 369     return $self->{CFLAGS} = qq{
 370 CCFLAGS = $self->{CCFLAGS}
 371 OPTIMIZE = $self->{OPTIMIZE}
 372 PERLTYPE = $self->{PERLTYPE}
 373 LARGE = $self->{LARGE}
 374 SPLIT = $self->{SPLIT}
 375 };
 376
 377 }
 378
 379 =item clean (o)
 380
 381 Defines the clean target.
 382
 383 =cut
 384
 385 sub clean {
 386 # --- Cleanup and Distribution Sections ---
 387
 388     my($self, %attribs) = @_;
 389     my(@m,$dir);
 390     push(@m, '
 391 # Delete temporary files but do not touch installed files. We don\'t delete
 392 # the Makefile here so a later make realclean still has a makefile to use.
 393
 394 clean ::
 395 ');
 396     # clean subdirectories first
 397     for $dir (@{$self->{DIR}}) {
 398         push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
 399     }
 400
 401     my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
 402     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
 403     push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
 404                          perlmain.c mon.out core so_locations pm_to_blib
 405                          *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe
 406                          $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
 407                          $(BASEEXT).exp
 408                         ]);
 409     push @m, "\t-$self->{RM_RF} @otherfiles\n";
 410     # See realclean and ext/utils/make_ext for usage of Makefile.old
 411     push(@m,
 412          "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
 413     push(@m,
 414          "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
 415     join("", @m);
 416 }
 417
 418 =item const_cccmd (o)
 419
 420 Returns the full compiler call for C programs and stores the
 421 definition in CONST_CCCMD.
 422
 423 =cut
 424
 425 sub const_cccmd {
 426     my($self,$libperl)=@_;
 427     return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
 428     return '' unless $self->needs_linking();
 429     return $self->{CONST_CCCMD} =
 430         q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
 431         $(PERLTYPE) $(LARGE) $(SPLIT) $(DEFINE_VERSION) \\
 432         $(XS_DEFINE_VERSION)};
 433 }
 434
 435 =item const_config (o)
 436
 437 Defines a couple of constants in the Makefile that are imported from
 438 %Config.
 439
 440 =cut
 441
 442 sub const_config {
 443 # --- Constants Sections ---
 444
 445     my($self) = shift;
 446     my(@m,$m);
 447     push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
 448     push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
 449     my(%once_only);
 450     foreach $m (@{$self->{CONFIG}}){
 451         # SITE*EXP macros are defined in &constants; avoid duplicates here
 452         next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
 453         push @m, "\U$m\E = ".$self->{uc $m}."\n";
 454         $once_only{$m} = 1;
 455     }
 456     join('', @m);
 457 }
 458
 459 =item const_loadlibs (o)
 460
 461 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
 462 L<ExtUtils::Liblist> for details.
 463
 464 =cut
 465
 466 sub const_loadlibs {
 467     my($self) = shift;
 468     return "" unless $self->needs_linking;
 469     my @m;
 470     push @m, qq{
 471 # $self->{NAME} might depend on some other libraries:
 472 # See ExtUtils::Liblist for details
 473 #
 474 };
 475     my($tmp);
 476     for $tmp (qw/
 477          EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
 478          /) {
 479         next unless defined $self->{$tmp};
 480         push @m, "$tmp = $self->{$tmp}\n";
 481     }
 482     return join "", @m;
 483 }
 484
 485 =item constants (o)
 486
 487 Initializes lots of constants and .SUFFIXES and .PHONY
 488
 489 =cut
 490
 491 sub constants {
 492     my($self) = @_;
 493     my(@m,$tmp);
 494
 495     for $tmp (qw/
 496
 497               AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
 498               VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
 499               INST_ARCHLIB INST_SCRIPT PREFIX  INSTALLDIRS
 500               INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
 501               INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
 502               PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
 503               FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
 504               PERL_INC PERL FULLPERL
 505
 506               / ) {
 507         next unless defined $self->{$tmp};
 508         push @m, "$tmp = $self->{$tmp}\n";
 509     }
 510
 511     push @m, qq{
 512 VERSION_MACRO = VERSION
 513 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
 514 XS_VERSION_MACRO = XS_VERSION
 515 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
 516 };
 517
 518     push @m, qq{
 519 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
 520 MM_VERSION = $ExtUtils::MakeMaker::VERSION
 521 };
 522
 523     push @m, q{
 524 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
 525 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
 526 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)  !!! Deprecated from MM 5.32  !!!
 527 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
 528 # DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
 529 };
 530
 531     for $tmp (qw/
 532               FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
 533               LDFROM LINKTYPE
 534               / ) {
 535         next unless defined $self->{$tmp};
 536         push @m, "$tmp = $self->{$tmp}\n";
 537     }
 538
 539     push @m, "
 540 # Handy lists of source code files:
 541 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
 542 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
 543 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
 544 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
 545 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
 546 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
 547 ";
 548
 549     for $tmp (qw/
 550               INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
 551               /) {
 552         next unless defined $self->{$tmp};
 553         push @m, "$tmp = $self->{$tmp}\n";
 554     }
 555
 556     push @m, q{
 557 .NO_CONFIG_REC: Makefile
 558 } if $ENV{CLEARCASE_ROOT};
 559
 560     # why not q{} ? -- emacs
 561     push @m, qq{
 562 # work around a famous dec-osf make(1) feature(?):
 563 makemakerdflt: all
 564
 565 .SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
 566
 567 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
 568 # some make implementations will delete the Makefile when we rebuild it. Because
 569 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
 570 # does so. Our milage may vary.
 571 # .PRECIOUS: Makefile    # seems to be not necessary anymore
 572
 573 .PHONY: all config static dynamic test linkext manifest
 574
 575 # Where is the Config information that we are using/depend on
 576 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
 577 };
 578
 579     my @parentdir = split(/::/, $self->{PARENT_NAME});
 580     push @m, q{
 581 # Where to put things:
 582 INST_LIBDIR      = }. $self->catdir('$(INST_LIB)',@parentdir)        .q{
 583 INST_ARCHLIBDIR  = }. $self->catdir('$(INST_ARCHLIB)',@parentdir)    .q{
 584
 585 INST_AUTODIR     = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)')       .q{
 586 INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)')   .q{
 587 };
 588
 589     if ($self->has_link_code()) {
 590         push @m, '
 591 INST_STATIC  = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
 592 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
 593 INST_BOOT    = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
 594 ';
 595     } else {
 596         push @m, '
 597 INST_STATIC  =
 598 INST_DYNAMIC =
 599 INST_BOOT    =
 600 ';
 601     }
 602
 603     if ($Is_OS2) {
 604         $tmp = "$self->{BASEEXT}.def";
 605     } else {
 606         $tmp = "";
 607     }
 608     push @m, "
 609 EXPORT_LIST = $tmp
 610 ";
 611
 612     if ($Is_OS2) {
 613         $tmp = "\$(PERL_INC)/libperl\$(LIB_EXT)";
 614     } else {
 615         $tmp = "";
 616     }
 617     push @m, "
 618 PERL_ARCHIVE = $tmp
 619 ";
 620
 621 #    push @m, q{
 622 #INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
 623 #
 624 #PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
 625 #};
 626
 627     push @m, q{
 628 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
 629
 630 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
 631 };
 632
 633     join('',@m);
 634 }
 635
 636 =item depend (o)
 637
 638 Same as macro for the depend attribute.
 639
 640 =cut
 641
 642 sub depend {
 643     my($self,%attribs) = @_;
 644     my(@m,$key,$val);
 645     while (($key,$val) = each %attribs){
 646         last unless defined $key;
 647         push @m, "$key: $val\n";
 648     }
 649     join "", @m;
 650 }
 651
 652 =item dir_target (o)
 653
 654 Takes an array of directories that need to exist and returns a
 655 Makefile entry for a .exists file in these directories. Returns
 656 nothing, if the entry has already been processed. We're helpless
 657 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
 658 them get an entry, that's why we use "::".
 659
 660 =cut
 661
 662 sub dir_target {
 663 # --- Make-Directories section (internal method) ---
 664 # dir_target(@array) returns a Makefile entry for the file .exists in each
 665 # named directory. Returns nothing, if the entry has already been processed.
 666 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
 667 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
 668 # prerequisite, because there has to be one, something that doesn't change
 669 # too often :)
 670
 671     my($self,@dirs) = @_;
 672     my(@m,$dir);
 673     foreach $dir (@dirs) {
 674         my($src) = $self->catfile($self->{PERL_INC},'perl.h');
 675         my($targ) = $self->catfile($dir,'.exists');
 676         my($targdir) = $targ;       # Necessary because catfile may have
 677         $targdir =~ s:/?.exists$::; # adapted syntax of $dir to target OS
 678         next if $self->{DIR_TARGET}{$self}{$targdir}++;
 679         push @m, qq{
 680 $targ :: $src
 681         $self->{NOECHO}\$(MKPATH) $targdir
 682         $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
 683 };
 684         push(@m,qq{
 685         -$self->{NOECHO}\$(CHMOD) 755 $targdir
 686 }) unless $Is_VMS;
 687     }
 688     join "", @m;
 689 }
 690
 691 =item dist (o)
 692
 693 Defines a lot of macros for distribution support.
 694
 695 =cut
 696
 697 sub dist {
 698     my($self, %attribs) = @_;
 699
 700     my(@m);
 701     # VERSION should be sanitised before use as a file name
 702     my($version)  = $attribs{VERSION}  || '$(VERSION)';
 703     my($name)     = $attribs{NAME}     || '$(DISTNAME)';
 704     my($tar)      = $attribs{TAR}      || 'tar';        # eg /usr/bin/gnutar
 705     my($tarflags) = $attribs{TARFLAGS} || 'cvf';
 706     my($zip)      = $attribs{ZIP}      || 'zip';        # eg pkzip Yuck!
 707     my($zipflags) = $attribs{ZIPFLAGS} || '-r';
 708     my($compress) = $attribs{COMPRESS} || 'compress';   # eg gzip
 709     my($suffix)   = $attribs{SUFFIX}   || '.Z';          # eg .gz
 710     my($shar)     = $attribs{SHAR}     || 'shar';       # eg "shar --gzip"
 711     my($preop)    = $attribs{PREOP}    || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
 712     my($postop)   = $attribs{POSTOP}   || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
 713
 714     my($to_unix)  = $attribs{TO_UNIX} || ($Is_OS2
 715                                           ? "$self->{NOECHO}"
 716                                           . 'test -f tmp.zip && $(RM) tmp.zip;'
 717                                           . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
 718                                           : "$self->{NOECHO}\$(NOOP)");
 719
 720     my($ci)       = $attribs{CI}       || 'ci -u';
 721     my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
 722     my($dist_cp)  = $attribs{DIST_CP}  || 'best';
 723     my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
 724
 725     push @m, "
 726 DISTVNAME = ${name}-$version
 727 TAR  = $tar
 728 TARFLAGS = $tarflags
 729 ZIP  = $zip
 730 ZIPFLAGS = $zipflags
 731 COMPRESS = $compress
 732 SUFFIX = $suffix
 733 SHAR = $shar
 734 PREOP = $preop
 735 POSTOP = $postop
 736 TO_UNIX = $to_unix
 737 CI = $ci
 738 RCS_LABEL = $rcs_label
 739 DIST_CP = $dist_cp
 740 DIST_DEFAULT = $dist_default
 741 ";
 742     join "", @m;
 743 }
 744
 745 =item dist_basics (o)
 746
 747 Defines the targets distclean, distcheck, skipcheck, manifest.
 748
 749 =cut
 750
 751 sub dist_basics {
 752     my($self) = shift;
 753     my @m;
 754     push @m, q{
 755 distclean :: realclean distcheck
 756 };
 757
 758     push @m, q{
 759 distcheck :
 760         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
 761                 -e 'fullcheck();'
 762 };
 763
 764     push @m, q{
 765 skipcheck :
 766         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
 767                 -e 'skipcheck();'
 768 };
 769
 770     push @m, q{
 771 manifest :
 772         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
 773                 -e 'mkmanifest();'
 774 };
 775     join "", @m;
 776 }
 777
 778 =item dist_ci (o)
 779
 780 Defines a check in target for RCS.
 781
 782 =cut
 783
 784 sub dist_ci {
 785     my($self) = shift;
 786     my @m;
 787     push @m, q{
 788 ci :
 789         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
 790                 -e '@all = keys %{ maniread() };' \\
 791                 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
 792                 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
 793 };
 794     join "", @m;
 795 }
 796
 797 =item dist_core (o)
 798
 799 Defeines the targets dist, tardist, zipdist, uutardist, shdist
 800
 801 =cut
 802
 803 sub dist_core {
 804     my($self) = shift;
 805     my @m;
 806     push @m, q{
 807 dist : $(DIST_DEFAULT)
 808         }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
 809             -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
 810
 811 tardist : $(DISTVNAME).tar$(SUFFIX)
 812
 813 zipdist : $(DISTVNAME).zip
 814
 815 $(DISTVNAME).tar$(SUFFIX) : distdir
 816         $(PREOP)
 817         $(TO_UNIX)
 818         $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
 819         $(RM_RF) $(DISTVNAME)
 820         $(COMPRESS) $(DISTVNAME).tar
 821         $(POSTOP)
 822
 823 $(DISTVNAME).zip : distdir
 824         $(PREOP)
 825         $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
 826         $(RM_RF) $(DISTVNAME)
 827         $(POSTOP)
 828
 829 uutardist : $(DISTVNAME).tar$(SUFFIX)
 830         uuencode $(DISTVNAME).tar$(SUFFIX) \\
 831                 $(DISTVNAME).tar$(SUFFIX) > \\
 832                 $(DISTVNAME).tar$(SUFFIX)_uu
 833
 834 shdist : distdir
 835         $(PREOP)
 836         $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
 837         $(RM_RF) $(DISTVNAME)
 838         $(POSTOP)
 839 };
 840     join "", @m;
 841 }
 842
 843 =item dist_dir (o)
 844
 845 Defines the scratch directory target that will hold the distribution
 846 before tar-ing (or shar-ing).
 847
 848 =cut
 849
 850 sub dist_dir {
 851     my($self) = shift;
 852     my @m;
 853     push @m, q{
 854 distdir :
 855         $(RM_RF) $(DISTVNAME)
 856         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
 857                 -e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
 858 };
 859     join "", @m;
 860 }
 861
 862 =item dist_test (o)
 863
 864 Defines a target that produces the distribution in the
 865 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
 866 subdirectory.
 867
 868 =cut
 869
 870 sub dist_test {
 871     my($self) = shift;
 872     my @m;
 873     push @m, q{
 874 disttest : distdir
 875         cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
 876         cd $(DISTVNAME) && $(MAKE)
 877         cd $(DISTVNAME) && $(MAKE) test
 878 };
 879     join "", @m;
 880 }
 881
 882 =item dlsyms (o)
 883
 884 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
 885 files.
 886
 887 =cut
 888
 889 sub dlsyms {
 890     my($self,%attribs) = @_;
 891
 892     return '' unless ($^O eq 'aix' && $self->needs_linking() );
 893
 894     my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
 895     my($vars)  = $attribs{DL_VARS} || $self->{DL_VARS} || [];
 896     my(@m);
 897
 898     push(@m,"
 899 dynamic :: $self->{BASEEXT}.exp
 900
 901 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
 902
 903     push(@m,"
 904 static :: $self->{BASEEXT}.exp
 905
 906 ") unless $self->{SKIPHASH}{'static'};  # we avoid a warning if we tick them
 907
 908     push(@m,"
 909 $self->{BASEEXT}.exp: Makefile.PL
 910 ",'     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
 911         Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
 912         neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
 913 ');
 914
 915     join('',@m);
 916 }
 917
 918 =item dynamic (o)
 919
 920 Defines the dynamic target.
 921
 922 =cut
 923
 924 sub dynamic {
 925 # --- Dynamic Loading Sections ---
 926
 927     my($self) = shift;
 928     '
 929 ## $(INST_PM) has been moved to the all: target.
 930 ## It remains here for awhile to allow for old usage: "make dynamic"
 931 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
 932 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
 933         '.$self->{NOECHO}.'$(NOOP)
 934 ';
 935 }
 936
 937 =item dynamic_bs (o)
 938
 939 Defines targets for bootstrap files.
 940
 941 =cut
 942
 943 sub dynamic_bs {
 944     my($self, %attribs) = @_;
 945     return '
 946 BOOTSTRAP =
 947 ' unless $self->has_link_code();
 948
 949     return '
 950 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
 951
 952 # As Mkbootstrap might not write a file (if none is required)
 953 # we use touch to prevent make continually trying to remake it.
 954 # The DynaLoader only reads a non-empty file.
 955 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
 956         '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
 957         '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
 958                 -e \'use ExtUtils::Mkbootstrap;\' \
 959                 -e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
 960         '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
 961         $(CHMOD) 644 $@
 962
 963 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
 964         '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
 965         -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
 966         $(CHMOD) 644 $@
 967 ';
 968 }
 969
 970 =item dynamic_lib (o)
 971
 972 Defines how to produce the *.so (or equivalent) files.
 973
 974 =cut
 975
 976 sub dynamic_lib {
 977     my($self, %attribs) = @_;
 978     return '' unless $self->needs_linking(); #might be because of a subdir
 979
 980     return '' unless $self->has_link_code;
 981
 982     my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
 983     my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
 984     my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
 985     my($ldfrom) = '$(LDFROM)';
 986     $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
 987     my(@m);
 988     push(@m,'
 989 # This section creates the dynamically loadable $(INST_DYNAMIC)
 990 # from $(OBJECT) and possibly $(MYEXTLIB).
 991 ARMAYBE = '.$armaybe.'
 992 OTHERLDFLAGS = '.$otherldflags.'
 993 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
 994
 995 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
 996 ');
 997     if ($armaybe ne ':'){
 998         $ldfrom = 'tmp$(LIB_EXT)';
 999         push(@m,'       $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1000         push(@m,'       $(RANLIB) '."$ldfrom\n");
1001     }
1002     $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1003
1004     # Brain dead solaris linker does not use LD_RUN_PATH?
1005     # This fixes dynamic extensions which need shared libs
1006     my $ldrun = '';
1007     $ldrun = join ' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}
1008        if ($^O eq 'solaris');
1009
1010     push(@m,'   LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1011                 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)');
1012     push @m, '
1013         $(CHMOD) 755 $@
1014 ';
1015
1016     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1017     join('',@m);
1018 }
1019
1020 =item exescan
1021
1022 Deprecated method. Use libscan instead.
1023
1024 =cut
1025
1026 sub exescan {
1027     my($self,$path) = @_;
1028     $path;
1029 }
1030
1031 =item extliblist
1032
1033 Called by init_others, and calls ext ExtUtils::Liblist. See
1034 L<ExtUtils::Liblist> for details.
1035
1036 =cut
1037
1038 sub extliblist {
1039     my($self,$libs) = @_;
1040     require ExtUtils::Liblist;
1041     $self->ext($libs, $Verbose);
1042 }
1043
1044 =item file_name_is_absolute
1045
1046 Takes as argument a path and returns true, if it is an absolute path.
1047
1048 =cut
1049
1050 sub file_name_is_absolute {
1051     my($self,$file) = @_;
1052     $file =~ m:^/: ;
1053 }
1054
1055 =item find_perl
1056
1057 Finds the executables PERL and FULLPERL
1058
1059 =cut
1060
1061 sub find_perl {
1062     my($self, $ver, $names, $dirs, $trace) = @_;
1063     my($name, $dir);
1064     if ($trace >= 2){
1065         print "Looking for perl $ver by these names:
1066 @$names
1067 in these dirs:
1068 @$dirs
1069 ";
1070     }
1071     foreach $dir (@$dirs){
1072         next unless defined $dir; # $self->{PERL_SRC} may be undefined
1073         foreach $name (@$names){
1074             my ($abs, $val);
1075             if ($self->file_name_is_absolute($name)) { # /foo/bar
1076                 $abs = $name;
1077             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1078                 $abs = $self->catfile($dir, $name);
1079             } else { # foo/bar
1080                 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1081             }
1082             print "Checking $abs\n" if ($trace >= 2);
1083             next unless $self->maybe_command($abs);
1084             print "Executing $abs\n" if ($trace >= 2);
1085             $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1086             if ($val =~ /VER_OK/) {
1087                 print "Using PERL=$abs\n" if $trace;
1088                 return $abs;
1089             } elsif ($trace >= 2) {
1090                 print "Result: `$val'\n";
1091             }
1092         }
1093     }
1094     print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1095     0; # false and not empty
1096 }
1097
1098 =back
1099
1100 =head2 Methods to actually produce chunks of text for the Makefile
1101
1102 The methods here are called for each MakeMaker object in the order
1103 specified by @ExtUtils::MakeMaker::MM_Sections.
1104
1105 =over 2
1106
1107 =item force (o)
1108
1109 Just writes FORCE:
1110
1111 =cut
1112
1113 sub force {
1114     my($self) = shift;
1115     '# Phony target to force checking subdirectories.
1116 FORCE:
1117 ';
1118 }
1119
1120 =item guess_name
1121
1122 Guess the name of this package by examining the working directory's
1123 name. MakeMaker calls this only if the developer has not supplied a
1124 NAME attribute.
1125
1126 =cut
1127
1128 # ';
1129
1130 sub guess_name {
1131     my($self) = @_;
1132     use Cwd 'cwd';
1133     my $name = basename(cwd());
1134     $name =~ s|[\-_][\d\.\-]+$||;   # this is new with MM 5.00, we
1135                                     # strip minus or underline
1136                                     # followed by a float or some such
1137     print "Warning: Guessing NAME [$name] from current directory name.\n";
1138     $name;
1139 }
1140
1141 =item has_link_code
1142
1143 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1144 object that need a compiler. Does not descend into subdirectories as
1145 needs_linking() does.
1146
1147 =cut
1148
1149 sub has_link_code {
1150     my($self) = shift;
1151     return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1152     if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1153         $self->{HAS_LINK_CODE} = 1;
1154         return 1;
1155     }
1156     return $self->{HAS_LINK_CODE} = 0;
1157 }
1158
1159 =item init_dirscan
1160
1161 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1162
1163 =cut
1164
1165 sub init_dirscan {      # --- File and Directory Lists (.xs .pm .pod etc)
1166     my($self) = @_;
1167     my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1168     local(%pm); #the sub in find() has to see this hash
1169     $ignore{'test.pl'} = 1;
1170     $ignore{'makefile.pl'} = 1 if $Is_VMS;
1171     foreach $name ($self->lsdir($self->curdir)){
1172         next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1173         next unless $self->libscan($name);
1174         if (-d $name){
1175             next if -l $name; # We do not support symlinks at all
1176             $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1177         } elsif ($name =~ /\.xs$/){
1178             my($c); ($c = $name) =~ s/\.xs$/.c/;
1179             $xs{$name} = $c;
1180             $c{$c} = 1;
1181         } elsif ($name =~ /\.c(pp|xx|c)?$/i){  # .c .C .cpp .cxx .cc
1182             $c{$name} = 1
1183                 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1184         } elsif ($name =~ /\.h$/i){
1185             $h{$name} = 1;
1186         } elsif ($name =~ /\.(p[ml]|pod)$/){
1187             $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1188         } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
1189             ($pl_files{$name} = $name) =~ s/\.PL$// ;
1190         } elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
1191                  $name ne 'test.pl') {  # case-insensitive filesystem
1192             ($pl_files{$name} = $name) =~ s/\.pl$// ;
1193         }
1194     }
1195
1196     # Some larger extensions often wish to install a number of *.pm/pl
1197     # files into the library in various locations.
1198
1199     # The attribute PMLIBDIRS holds an array reference which lists
1200     # subdirectories which we should search for library files to
1201     # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
1202     # recursively search through the named directories (skipping any
1203     # which don't exist or contain Makefile.PL files).
1204
1205     # For each *.pm or *.pl file found $self->libscan() is called with
1206     # the default installation path in $_[1]. The return value of
1207     # libscan defines the actual installation location.  The default
1208     # libscan function simply returns the path.  The file is skipped
1209     # if libscan returns false.
1210
1211     # The default installation location passed to libscan in $_[1] is:
1212     #
1213     #  ./*.pm           => $(INST_LIBDIR)/*.pm
1214     #  ./xyz/...        => $(INST_LIBDIR)/xyz/...
1215     #  ./lib/...        => $(INST_LIB)/...
1216     #
1217     # In this way the 'lib' directory is seen as the root of the actual
1218     # perl library whereas the others are relative to INST_LIBDIR
1219     # (which includes PARENT_NAME). This is a subtle distinction but one
1220     # that's important for nested modules.
1221
1222     $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1223         unless $self->{PMLIBDIRS};
1224
1225     #only existing directories that aren't in $dir are allowed
1226
1227     # Avoid $_ wherever possible:
1228     # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1229     my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1230     my ($pmlibdir);
1231     @{$self->{PMLIBDIRS}} = ();
1232     foreach $pmlibdir (@pmlibdirs) {
1233         -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1234     }
1235
1236     if (@{$self->{PMLIBDIRS}}){
1237         print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1238             if ($Verbose >= 2);
1239         require File::Find;
1240         File::Find::find(sub {
1241             if (-d $_){
1242                 if ($_ eq "CVS" || $_ eq "RCS"){
1243                     $File::Find::prune = 1;
1244                 }
1245                 return;
1246             }
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, 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     $prefix = VMS::Filespec::unixify($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, 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->{CP} ||= "cp";
1780     $self->{MV} ||= "mv";
1781     $self->{CHMOD} ||= "chmod";
1782     $self->{UMASK_NULL} ||= "umask 0";
1783 }
1784
1785 =item install (o)
1786
1787 Defines the install target.
1788
1789 =cut
1790
1791 sub install {
1792     my($self, %attribs) = @_;
1793     my(@m);
1794
1795     push @m, q{
1796 install :: all pure_install doc_install
1797
1798 install_perl :: all pure_perl_install doc_perl_install
1799
1800 install_site :: all pure_site_install doc_site_install
1801
1802 install_ :: install_site
1803         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1804
1805 pure_install :: pure_$(INSTALLDIRS)_install
1806
1807 doc_install :: doc_$(INSTALLDIRS)_install
1808         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
1809
1810 pure__install : pure_site_install
1811         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1812
1813 doc__install : doc_site_install
1814         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1815
1816 pure_perl_install ::
1817         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1818                 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1819                 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1820                 $(INST_LIB) $(INSTALLPRIVLIB) \
1821                 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
1822                 $(INST_BIN) $(INSTALLBIN) \
1823                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1824                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1825                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1826         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1827                 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
1828
1829
1830 pure_site_install ::
1831         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1832                 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
1833                 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
1834                 $(INST_LIB) $(INSTALLSITELIB) \
1835                 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
1836                 $(INST_BIN) $(INSTALLBIN) \
1837                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1838                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1839                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1840         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1841                 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
1842
1843 doc_perl_install ::
1844         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1845                 "Module" "$(NAME)" \
1846                 "installed into" "$(INSTALLPRIVLIB)" \
1847                 LINKTYPE "$(LINKTYPE)" \
1848                 VERSION "$(VERSION)" \
1849                 EXE_FILES "$(EXE_FILES)" \
1850                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1851
1852 doc_site_install ::
1853         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1854                 "Module" "$(NAME)" \
1855                 "installed into" "$(INSTALLSITELIB)" \
1856                 LINKTYPE "$(LINKTYPE)" \
1857                 VERSION "$(VERSION)" \
1858                 EXE_FILES "$(EXE_FILES)" \
1859                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1860
1861 };
1862
1863     push @m, q{
1864 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
1865
1866 uninstall_from_perldirs ::
1867         }.$self->{NOECHO}.
1868         q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
1869
1870 uninstall_from_sitedirs ::
1871         }.$self->{NOECHO}.
1872         q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
1873 };
1874
1875     join("",@m);
1876 }
1877
1878 =item installbin (o)
1879
1880 Defines targets to install EXE_FILES.
1881
1882 =cut
1883
1884 sub installbin {
1885     my($self) = shift;
1886     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
1887     return "" unless @{$self->{EXE_FILES}};
1888     my(@m, $from, $to, %fromto, @to);
1889     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
1890     for $from (@{$self->{EXE_FILES}}) {
1891         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
1892         local($_) = $path; # for backwards compatibility
1893         $to = $self->libscan($path);
1894         print "libscan($from) => '$to'\n" if ($Verbose >=2);
1895         $fromto{$from}=$to;
1896     }
1897     @to   = values %fromto;
1898     push(@m, "
1899 EXE_FILES = @{$self->{EXE_FILES}}
1900
1901 all :: @to
1902
1903 realclean ::
1904         $self->{RM_F} @to
1905 ");
1906
1907     while (($from,$to) = each %fromto) {
1908         last unless defined $from;
1909         my $todir = dirname($to);
1910         push @m, "
1911 $to: $from $self->{MAKEFILE} $todir/.exists
1912         $self->{NOECHO}$self->{RM_F} $to
1913         $self->{CP} $from $to
1914 ";
1915     }
1916     join "", @m;
1917 }
1918
1919 =item libscan (o)
1920
1921 Takes a path to a file that is found by init_dirscan and returns false
1922 if we don't want to include this file in the library. Mainly used to
1923 exclude RCS, CVS, and SCCS directories from installation.
1924
1925 =cut
1926
1927 # ';
1928
1929 sub libscan {
1930     my($self,$path) = @_;
1931     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
1932     $path;
1933 }
1934
1935 =item linkext (o)
1936
1937 Defines the linkext target which in turn defines the LINKTYPE.
1938
1939 =cut
1940
1941 sub linkext {
1942     my($self, %attribs) = @_;
1943     # LINKTYPE => static or dynamic or ''
1944     my($linktype) = defined $attribs{LINKTYPE} ?
1945       $attribs{LINKTYPE} : '$(LINKTYPE)';
1946     "
1947 linkext :: $linktype
1948         $self->{NOECHO}\$(NOOP)
1949 ";
1950 }
1951
1952 =item lsdir
1953
1954 Takes as arguments a directory name and a regular expression. Returns
1955 all entries in the directory that match the regular expression.
1956
1957 =cut
1958
1959 sub lsdir {
1960     my($self) = shift;
1961     my($dir, $regex) = @_;
1962     my(@ls);
1963     my $dh = new DirHandle;
1964     $dh->open($dir || ".") or return ();
1965     @ls = $dh->read;
1966     $dh->close;
1967     @ls = grep(/$regex/, @ls) if $regex;
1968     @ls;
1969 }
1970
1971 =item macro (o)
1972
1973 Simple subroutine to insert the macros defined by the macro attribute
1974 into the Makefile.
1975
1976 =cut
1977
1978 sub macro {
1979     my($self,%attribs) = @_;
1980     my(@m,$key,$val);
1981     while (($key,$val) = each %attribs){
1982         last unless defined $key;
1983         push @m, "$key = $val\n";
1984     }
1985     join "", @m;
1986 }
1987
1988 =item makeaperl (o)
1989
1990 Called by staticmake. Defines how to write the Makefile to produce a
1991 static new perl.
1992
1993 By default the Makefile produced includes all the static extensions in
1994 the perl library. (Purified versions of library files, e.g.,
1995 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
1996
1997 =cut
1998
1999 sub makeaperl {
2000     my($self, %attribs) = @_;
2001     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2002         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2003     my(@m);
2004     push @m, "
2005 # --- MakeMaker makeaperl section ---
2006 MAP_TARGET    = $target
2007 FULLPERL      = $self->{FULLPERL}
2008 ";
2009     return join '', @m if $self->{PARENT};
2010
2011     my($dir) = join ":", @{$self->{DIR}};
2012
2013     unless ($self->{MAKEAPERL}) {
2014         push @m, q{
2015 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2016         $(MAKE) -f $(MAKE_APERL_FILE) $@
2017
2018 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2019         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2020         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2021                 Makefile.PL DIR=}, $dir, q{ \
2022                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2023                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2024
2025         foreach (@ARGV){
2026                 if( /\s/ ){
2027                         s/=(.*)/='$1'/;
2028                 }
2029                 push @m, " \\\n\t\t$_";
2030         }
2031 #       push @m, map( " \\\n\t\t$_", @ARGV );
2032         push @m, "\n";
2033
2034         return join '', @m;
2035     }
2036
2037
2038
2039     my($cccmd, $linkcmd, $lperl);
2040
2041
2042     $cccmd = $self->const_cccmd($libperl);
2043     $cccmd =~ s/^CCCMD\s*=\s*//;
2044     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2045     $cccmd .= " $Config::Config{cccdlflags}"
2046         if ($Config::Config{useshrplib} eq 'true');
2047     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2048
2049     # The front matter of the linkcommand...
2050     $linkcmd = join ' ', "\$(CC)",
2051             grep($_, @Config{qw(large split ldflags ccdlflags)});
2052     $linkcmd =~ s/\s+/ /g;
2053     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2054
2055     # Which *.a files could we make use of...
2056     local(%static);
2057     require File::Find;
2058     File::Find::find(sub {
2059         return unless m/\Q$self->{LIB_EXT}\E$/;
2060         return if m/^libperl/;
2061         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2062         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2063
2064         if( exists $self->{INCLUDE_EXT} ){
2065                 my $found = 0;
2066                 my $incl;
2067                 my $xx;
2068
2069                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2070                 $xx =~ s,/?$_,,;
2071                 $xx =~ s,/,::,g;
2072
2073                 # Throw away anything not explicitly marked for inclusion.
2074                 # DynaLoader is implied.
2075                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2076                         if( $xx eq $incl ){
2077                                 $found++;
2078                                 last;
2079                         }
2080                 }
2081                 return unless $found;
2082         }
2083         elsif( exists $self->{EXCLUDE_EXT} ){
2084                 my $excl;
2085                 my $xx;
2086
2087                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2088                 $xx =~ s,/?$_,,;
2089                 $xx =~ s,/,::,g;
2090
2091                 # Throw away anything explicitly marked for exclusion
2092                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2093                         return if( $xx eq $excl );
2094                 }
2095         }
2096
2097         # don't include the installed version of this extension. I
2098         # leave this line here, although it is not necessary anymore:
2099         # I patched minimod.PL instead, so that Miniperl.pm won't
2100         # enclude duplicates
2101
2102         # Once the patch to minimod.PL is in the distribution, I can
2103         # drop it
2104         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2105         use Cwd 'cwd';
2106         $static{cwd() . "/" . $_}++;
2107     }, grep( -d $_, @{$searchdirs || []}) );
2108
2109     # We trust that what has been handed in as argument, will be buildable
2110     $static = [] unless $static;
2111     @static{@{$static}} = (1) x @{$static};
2112
2113     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2114     for (sort keys %static) {
2115         next unless /\Q$self->{LIB_EXT}\E$/;
2116         $_ = dirname($_) . "/extralibs.ld";
2117         push @$extra, $_;
2118     }
2119
2120     grep(s/^/-I/, @{$perlinc || []});
2121
2122     $target = "perl" unless $target;
2123     $tmp = "." unless $tmp;
2124
2125 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2126 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2127 # extralibs.all are computed correctly
2128     push @m, "
2129 MAP_LINKCMD   = $linkcmd
2130 MAP_PERLINC   = @{$perlinc || []}
2131 MAP_STATIC    = ",
2132 join(" \\\n\t", reverse sort keys %static), "
2133
2134 MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
2135 ";
2136
2137     if (defined $libperl) {
2138         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2139     }
2140     unless ($libperl && -f $lperl) { # Ilya's code...
2141         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2142         $libperl ||= "libperl$self->{LIB_EXT}";
2143         $libperl   = "$dir/$libperl";
2144         $lperl   ||= "libperl$self->{LIB_EXT}";
2145         $lperl     = "$dir/$lperl";
2146
2147         if (! -f $libperl and ! -f $lperl) {
2148           # We did not find a static libperl. Maybe there is a shared one?
2149           if ($^O eq 'solaris' or $^O eq 'sunos') {
2150             $lperl  = $libperl = "$dir/$Config::Config{libperl}";
2151             # SUNOS ld does not take the full path to a shared library
2152             $libperl = '' if $^O eq 'sunos';
2153           }
2154         }
2155
2156         print STDOUT "Warning: $libperl not found
2157     If you're going to build a static perl binary, make sure perl is installed
2158     otherwise ignore this warning\n"
2159                 unless (-f $lperl || defined($self->{PERL_SRC}));
2160     }
2161
2162     push @m, "
2163 MAP_LIBPERL = $libperl
2164 ";
2165
2166     push @m, "
2167 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2168         $self->{NOECHO}$self->{RM_F} \$\@
2169         $self->{NOECHO}\$(TOUCH) \$\@
2170 ";
2171
2172     my $catfile;
2173     foreach $catfile (@$extra){
2174         push @m, "\tcat $catfile >> \$\@\n";
2175     }
2176     # SUNOS ld does not take the full path to a shared library
2177     my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2178
2179     # Brain dead solaris linker does not use LD_RUN_PATH?
2180     # This fixes dynamic extensions which need shared libs
2181     my $ldfrom = ($^O eq 'solaris')?
2182            join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2183
2184 push @m, "
2185 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2186         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom $llibperl \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2187         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2188         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2189         $self->{NOECHO}echo 'To remove the intermediate files say'
2190         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2191
2192 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2193 ";
2194     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2195
2196     push @m, qq{
2197 $tmp/perlmain.c: $makefilename}, q{
2198         }.$self->{NOECHO}.q{echo Writing $@
2199         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
2200                 writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@t && mv $@t $@
2201
2202 };
2203
2204     push @m, q{
2205 doc_inst_perl:
2206         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2207         }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2208                 "Perl binary" "$(MAP_TARGET)" \
2209                 MAP_STATIC "$(MAP_STATIC)" \
2210                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2211                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2212                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2213
2214 };
2215
2216     push @m, q{
2217 inst_perl: pure_inst_perl doc_inst_perl
2218
2219 pure_inst_perl: $(MAP_TARGET)
2220         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2221
2222 clean :: map_clean
2223
2224 map_clean :
2225         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2226 };
2227
2228     join '', @m;
2229 }
2230
2231 =item makefile (o)
2232
2233 Defines how to rewrite the Makefile.
2234
2235 =cut
2236
2237 sub makefile {
2238     my($self) = shift;
2239     my @m;
2240     # We do not know what target was originally specified so we
2241     # must force a manual rerun to be sure. But as it should only
2242     # happen very rarely it is not a significant problem.
2243     push @m, '
2244 $(OBJECT) : $(FIRST_MAKEFILE)
2245 ' if $self->{OBJECT};
2246
2247     push @m, q{
2248 # We take a very conservative approach here, but it\'s worth it.
2249 # We move Makefile to Makefile.old here to avoid gnu make looping.
2250 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2251         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2252         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2253         -}.$self->{NOECHO}.q{mv }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2254         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean >/dev/null 2>&1 || true
2255         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2256         }.$self->{NOECHO}.q{echo ">>> Your Makefile has been rebuilt. <<<"
2257         }.$self->{NOECHO}.q{echo ">>> Please rerun the make command.  <<<"; false
2258
2259 # To change behavior to :: would be nice, but would break Tk b9.02
2260 # so you find such a warning below the dist target.
2261 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2262 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2263 };
2264
2265     join "", @m;
2266 }
2267
2268 =item manifypods (o)
2269
2270 Defines targets and routines to translate the pods into manpages and
2271 put them into the INST_* directories.
2272
2273 =cut
2274
2275 sub manifypods {
2276     my($self, %attribs) = @_;
2277     return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2278     my($dist);
2279     my($pod2man_exe);
2280     if (defined $self->{PERL_SRC}) {
2281         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2282     } else {
2283         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2284     }
2285     unless ($self->perl_script($pod2man_exe)) {
2286         # No pod2man but some MAN3PODS to be installed
2287         print <<END;
2288
2289 Warning: I could not locate your pod2man program. Please make sure,
2290          your pod2man program is in your PATH before you execute 'make'
2291
2292 END
2293         $pod2man_exe = "-S pod2man";
2294     }
2295     my(@m);
2296     push @m,
2297 qq[POD2MAN_EXE = $pod2man_exe\n],
2298 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2299 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2300 -e 'print "Manifying $$m{$$_}\n";' \\
2301 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2302 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2303 ];
2304     push @m, "\nmanifypods : ";
2305     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2306
2307     push(@m,"\n");
2308     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2309         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2310         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2311     }
2312     join('', @m);
2313 }
2314
2315 =item maybe_command
2316
2317 Returns true, if the argument is likely to be a command.
2318
2319 =cut
2320
2321 sub maybe_command {
2322     my($self,$file) = @_;
2323     return $file if -x $file && ! -d $file;
2324     return;
2325 }
2326
2327 =item maybe_command_in_dirs
2328
2329 method under development. Not yet used. Ask Ilya :-)
2330
2331 =cut
2332
2333 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2334 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2335     my($self, $names, $dirs, $trace, $ver) = @_;
2336     my($name, $dir);
2337     foreach $dir (@$dirs){
2338         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2339         foreach $name (@$names){
2340             my($abs,$tryabs);
2341             if ($self->file_name_is_absolute($name)) { # /foo/bar
2342                 $abs = $name;
2343             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2344                 $abs = $self->catfile($dir, $name);
2345             } else { # foo/bar
2346                 $abs = $self->catfile($self->curdir, $name);
2347             }
2348             print "Checking $abs for $name\n" if ($trace >= 2);
2349             next unless $tryabs = $self->maybe_command($abs);
2350             print "Substituting $tryabs instead of $abs\n"
2351                 if ($trace >= 2 and $tryabs ne $abs);
2352             $abs = $tryabs;
2353             if (defined $ver) {
2354                 print "Executing $abs\n" if ($trace >= 2);
2355                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2356                     print "Using PERL=$abs\n" if $trace;
2357                     return $abs;
2358                 }
2359             } else { # Do not look for perl
2360                 return $abs;
2361             }
2362         }
2363     }
2364 }
2365
2366 =item needs_linking (o)
2367
2368 Does this module need linking? Looks into subdirectory objects (see
2369 also has_link_code())
2370
2371 =cut
2372
2373 sub needs_linking {
2374     my($self) = shift;
2375     my($child,$caller);
2376     $caller = (caller(0))[3];
2377     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2378     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2379     if ($self->has_link_code or $self->{MAKEAPERL}){
2380         $self->{NEEDS_LINKING} = 1;
2381         return 1;
2382     }
2383     foreach $child (keys %{$self->{CHILDREN}}) {
2384         if ($self->{CHILDREN}->{$child}->needs_linking) {
2385             $self->{NEEDS_LINKING} = 1;
2386             return 1;
2387         }
2388     }
2389     return $self->{NEEDS_LINKING} = 0;
2390 }
2391
2392 =item nicetext
2393
2394 misnamed method (will have to be changed). The MM_Unix method just
2395 returns the argument without further processing.
2396
2397 On VMS used to insure that colons marking targets are preceded by
2398 space - most Unix Makes don't need this, but it's necessary under VMS
2399 to distinguish the target delimiter from a colon appearing as part of
2400 a filespec.
2401
2402 =cut
2403
2404 sub nicetext {
2405     my($self,$text) = @_;
2406     $text;
2407 }
2408
2409 =item parse_version
2410
2411 parse a file and return what you think is $VERSION in this file set to
2412
2413 =cut
2414
2415 sub parse_version {
2416     my($self,$parsefile) = @_;
2417     my $result;
2418     local *FH;
2419     local $/ = "\n";
2420     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2421     my $inpod = 0;
2422     while (<FH>) {
2423         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2424         next if $inpod;
2425         chop;
2426         next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2427         my $eval = qq{
2428             package ExtUtils::MakeMaker::_version;
2429             no strict;
2430
2431             \$$1=undef; do {
2432                 $_
2433             }; \$$1
2434         };
2435         local($^W) = 0;
2436         $result = eval($eval) || 0;
2437         die "Could not eval '$eval' in $parsefile: $@" if $@;
2438         last;
2439     }
2440     close FH;
2441     return $result;
2442 }
2443
2444
2445 =item pasthru (o)
2446
2447 Defines the string that is passed to recursive make calls in
2448 subdirectories.
2449
2450 =cut
2451
2452 sub pasthru {
2453     my($self) = shift;
2454     my(@m,$key);
2455
2456     my(@pasthru);
2457     my($sep) = $Is_VMS ? ',' : '';
2458     $sep .= "\\\n\t";
2459
2460     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2461         push @pasthru, "$key=\"\$($key)\"";
2462     }
2463
2464     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2465     join "", @m;
2466 }
2467
2468 =item path
2469
2470 Takes no argument, returns the environment variable PATH as an array.
2471
2472 =cut
2473
2474 sub path {
2475     my($self) = @_;
2476     my $path_sep = $Is_OS2 ? ";" : ":";
2477     my $path = $ENV{PATH};
2478     $path =~ s:\\:/:g if $Is_OS2;
2479     my @path = split $path_sep, $path;
2480     foreach(@path) { $_ = '.' if $_ eq '' }
2481     @path;
2482 }
2483
2484 =item perl_script
2485
2486 Takes one argument, a file name, and returns the file name, if the
2487 argument is likely to be a perl script. On MM_Unix this is true for
2488 any ordinary, readable file.
2489
2490 =cut
2491
2492 sub perl_script {
2493     my($self,$file) = @_;
2494     return $file if -r $file && -f _;
2495     return;
2496 }
2497
2498 =item perldepend (o)
2499
2500 Defines the dependency from all *.h files that come with the perl
2501 distribution.
2502
2503 =cut
2504
2505 sub perldepend {
2506     my($self) = shift;
2507     my(@m);
2508     push @m, q{
2509 # Check for unpropogated config.sh changes. Should never happen.
2510 # We do NOT just update config.h because that is not sufficient.
2511 # An out of date config.h is not fatal but complains loudly!
2512 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2513         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2514
2515 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2516         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2517         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2518 } if $self->{PERL_SRC};
2519
2520     return join "", @m unless $self->needs_linking;
2521
2522     push @m, q{
2523 PERL_HDRS = \
2524 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2525 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2526 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2527 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2528 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2529 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2530 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2531 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2532 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h                                \
2533 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2534
2535 $(OBJECT) : $(PERL_HDRS)
2536 } if $self->{OBJECT};
2537
2538     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2539
2540     join "\n", @m;
2541 }
2542
2543 =item pm_to_blib
2544
2545 Defines target that copies all files in the hash PM to their
2546 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2547
2548 =cut
2549
2550 sub pm_to_blib {
2551     my $self = shift;
2552     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2553     return q{
2554 pm_to_blib: $(TO_INST_PM)
2555         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2556         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2557         -e 'pm_to_blib({qw{$(PM_TO_BLIB)}},"}.$autodir.q{")'
2558         }.$self->{NOECHO}.q{$(TOUCH) $@
2559 };
2560 }
2561
2562 =item post_constants (o)
2563
2564 Returns an empty string per default. Dedicated to overrides from
2565 within Makefile.PL after all constants have been defined.
2566
2567 =cut
2568
2569 sub post_constants{
2570     my($self) = shift;
2571     "";
2572 }
2573
2574 =item post_initialize (o)
2575
2576 Returns an empty string per default. Used in Makefile.PLs to add some
2577 chunk of text to the Makefile after the object is initialized.
2578
2579 =cut
2580
2581 sub post_initialize {
2582     my($self) = shift;
2583     "";
2584 }
2585
2586 =item postamble (o)
2587
2588 Returns an empty string. Can be used in Makefile.PLs to write some
2589 text to the Makefile at the end.
2590
2591 =cut
2592
2593 sub postamble {
2594     my($self) = shift;
2595     "";
2596 }
2597
2598 =item prefixify
2599
2600 Check a path variable in $self from %Config, if it contains a prefix,
2601 and replace it with another one.
2602
2603 Takes as arguments an attribute name, a search prefix and a
2604 replacement prefix. Changes the attribute in the object.
2605
2606 =cut
2607
2608 sub prefixify {
2609     my($self,$var,$sprefix,$rprefix) = @_;
2610     $self->{uc $var} ||= $Config{lc $var};
2611     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2612     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2613 }
2614
2615 =item processPL (o)
2616
2617 Defines targets to run *.PL files.
2618
2619 =cut
2620
2621 sub processPL {
2622     my($self) = shift;
2623     return "" unless $self->{PL_FILES};
2624     my(@m, $plfile);
2625     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2626         push @m, "
2627 all :: $self->{PL_FILES}->{$plfile}
2628
2629 $self->{PL_FILES}->{$plfile} :: $plfile
2630         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2631 ";
2632     }
2633     join "", @m;
2634 }
2635
2636 =item realclean (o)
2637
2638 Defines the realclean target.
2639
2640 =cut
2641
2642 sub realclean {
2643     my($self, %attribs) = @_;
2644     my(@m);
2645     push(@m,'
2646 # Delete temporary files (via clean) and also delete installed files
2647 realclean purge ::  clean
2648 ');
2649     # realclean subdirectories first (already cleaned)
2650     my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
2651     foreach(@{$self->{DIR}}){
2652         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2653         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2654     }
2655     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2656     if( $self->has_link_code ){
2657         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2658         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
2659     }
2660     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
2661     my(@otherfiles) = ($self->{MAKEFILE},
2662                        "$self->{MAKEFILE}.old"); # Makefiles last
2663     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2664     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2665     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2666     join("", @m);
2667 }
2668
2669 =item replace_manpage_separator
2670
2671 Takes the name of a package, which may be a nested package, in the
2672 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2673
2674 =cut
2675
2676 sub replace_manpage_separator {
2677     my($self,$man) = @_;
2678     $man =~ s,/+,::,g;
2679     $man;
2680 }
2681
2682 =item static (o)
2683
2684 Defines the static target.
2685
2686 =cut
2687
2688 sub static {
2689 # --- Static Loading Sections ---
2690
2691     my($self) = shift;
2692     '
2693 ## $(INST_PM) has been moved to the all: target.
2694 ## It remains here for awhile to allow for old usage: "make static"
2695 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2696 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2697         '.$self->{NOECHO}.'$(NOOP)
2698 ';
2699 }
2700
2701 =item static_lib (o)
2702
2703 Defines how to produce the *.a (or equivalent) files.
2704
2705 =cut
2706
2707 sub static_lib {
2708     my($self) = @_;
2709 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2710 #    return '' unless $self->needs_linking(); #might be because of a subdir
2711
2712     return '' unless $self->has_link_code;
2713
2714     my(@m);
2715     push(@m, <<'END');
2716 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2717         $(RM_RF) $@
2718 END
2719     # If this extension has it's own library (eg SDBM_File)
2720     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2721     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2722
2723     push @m,
2724 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2725         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2726         $(CHMOD) 755 $@
2727 };
2728
2729 # Old mechanism - still available:
2730
2731     push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
2732         if $self->{PERL_SRC};
2733
2734     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2735     join('', "\n",@m);
2736 }
2737
2738 =item staticmake (o)
2739
2740 Calls makeaperl.
2741
2742 =cut
2743
2744 sub staticmake {
2745     my($self, %attribs) = @_;
2746     my(@static);
2747
2748     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
2749
2750     # And as it's not yet built, we add the current extension
2751     # but only if it has some C code (or XS code, which implies C code)
2752     if (@{$self->{C}}) {
2753         @static = $self->catfile($self->{INST_ARCHLIB},
2754                                  "auto",
2755                                  $self->{FULLEXT},
2756                                  "$self->{BASEEXT}$self->{LIB_EXT}"
2757                                 );
2758     }
2759
2760     # Either we determine now, which libraries we will produce in the
2761     # subdirectories or we do it at runtime of the make.
2762
2763     # We could ask all subdir objects, but I cannot imagine, why it
2764     # would be necessary.
2765
2766     # Instead we determine all libraries for the new perl at
2767     # runtime.
2768     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2769
2770     $self->makeaperl(MAKE       => $self->{MAKEFILE},
2771                      DIRS       => \@searchdirs,
2772                      STAT       => \@static,
2773                      INCL       => \@perlinc,
2774                      TARGET     => $self->{MAP_TARGET},
2775                      TMP        => "",
2776                      LIBPERL    => $self->{LIBPERL_A}
2777                     );
2778 }
2779
2780 =item subdir_x (o)
2781
2782 Helper subroutine for subdirs
2783
2784 =cut
2785
2786 sub subdir_x {
2787     my($self, $subdir) = @_;
2788     my(@m);
2789     qq{
2790
2791 subdirs ::
2792         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
2793
2794 };
2795 }
2796
2797 =item subdirs (o)
2798
2799 Defines targets to process subdirectories.
2800
2801 =cut
2802
2803 sub subdirs {
2804 # --- Sub-directory Sections ---
2805     my($self) = shift;
2806     my(@m,$dir);
2807     # This method provides a mechanism to automatically deal with
2808     # subdirectories containing further Makefile.PL scripts.
2809     # It calls the subdir_x() method for each subdirectory.
2810     foreach $dir (@{$self->{DIR}}){
2811         push(@m, $self->subdir_x($dir));
2812 ####    print "Including $dir subdirectory\n";
2813     }
2814     if (@m){
2815         unshift(@m, "
2816 # The default clean, realclean and test targets in this Makefile
2817 # have automatically been given entries for each subdir.
2818
2819 ");
2820     } else {
2821         push(@m, "\n# none")
2822     }
2823     join('',@m);
2824 }
2825
2826 =item test (o)
2827
2828 Defines the test targets.
2829
2830 =cut
2831
2832 sub test {
2833 # --- Test and Installation Sections ---
2834
2835     my($self, %attribs) = @_;
2836     my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2837     my(@m);
2838     push(@m,"
2839 TEST_VERBOSE=0
2840 TEST_TYPE=test_\$(LINKTYPE)
2841 TEST_FILE = test.pl
2842 TESTDB_SW = -d
2843
2844 testdb :: testdb_\$(LINKTYPE)
2845
2846 test :: \$(TEST_TYPE)
2847 ");
2848     push(@m, map("\t$self->{NOECHO}cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2849                  @{$self->{DIR}}));
2850     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
2851         unless $tests or -f "test.pl" or @{$self->{DIR}};
2852     push(@m, "\n");
2853
2854     push(@m, "test_dynamic :: pure_all\n");
2855     push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2856     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2857     push(@m, "\n");
2858
2859     push(@m, "testdb_dynamic :: pure_all\n");
2860     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
2861     push(@m, "\n");
2862
2863     # Occasionally we may face this degenerate target:
2864     push @m, "test_ : test_dynamic\n\n";
2865
2866     if ($self->needs_linking()) {
2867         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
2868         push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2869         push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2870         push(@m, "\n");
2871         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
2872         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
2873         push(@m, "\n");
2874     } else {
2875         push @m, "test_static :: test_dynamic\n";
2876         push @m, "testdb_static :: testdb_dynamic\n";
2877     }
2878     join("", @m);
2879 }
2880
2881 =item test_via_harness (o)
2882
2883 Helper method to write the test targets
2884
2885 =cut
2886
2887 sub test_via_harness {
2888     my($self, $perl, $tests) = @_;
2889     "\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";
2890 }
2891
2892 =item test_via_script (o)
2893
2894 Other helper method for test.
2895
2896 =cut
2897
2898 sub test_via_script {
2899     my($self, $perl, $script) = @_;
2900     qq{\tPERL_DL_NONLAZY=1 $perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
2901 };
2902 }
2903
2904 =item tool_autosplit (o)
2905
2906 Defines a simple perl call that runs autosplit. May be deprecated by
2907 pm_to_blib soon.
2908
2909 =cut
2910
2911 sub tool_autosplit {
2912 # --- Tool Sections ---
2913
2914     my($self, %attribs) = @_;
2915     my($asl) = "";
2916     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
2917     q{
2918 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
2919 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
2920 };
2921 }
2922
2923 =item tools_other (o)
2924
2925 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
2926 the Makefile. Also defines the perl programs MKPATH,
2927 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
2928
2929 =cut
2930
2931 sub tools_other {
2932     my($self) = shift;
2933     my @m;
2934     my $bin_sh = $Config{sh} || '/bin/sh';
2935     push @m, qq{
2936 SHELL = $bin_sh
2937 };
2938
2939     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TOUCH UMASK_NULL / ) {
2940         push @m, "$_ = $self->{$_}\n";
2941     }
2942
2943
2944     push @m, q{
2945 # The following is a portable way to say mkdir -p
2946 # To see which directories are created, change the if 0 to if 1
2947 MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
2948 -e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
2949 -e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
2950 -e 'mkdir("@p",0777)||die $$! } } exit 0;'
2951
2952 # This helps us to minimize the effect of the .exists files A yet
2953 # better solution would be to have a stable file in the perl
2954 # distribution with a timestamp of zero. But this solution doesn't
2955 # need any changes to the core distribution and works with older perls
2956 EQUALIZE_TIMESTAMP = $(PERL) -we 'open F, ">$$ARGV[1]"; close F;' \\
2957 -e 'utime ((stat("$$ARGV[0]"))[8,9], $$ARGV[1])'
2958 };
2959
2960     return join "", @m if $self->{PARENT};
2961
2962     push @m, q{
2963 # Here we warn users that an old packlist file was found somewhere,
2964 # and that they should call some uninstall routine
2965 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
2966 -e 'print "WARNING: I have found an old package in\n";' \\
2967 -e 'print "\t$$ARGV[0].\n";' \\
2968 -e 'print "Please make sure the two installations are not conflicting\n";'
2969
2970 UNINST=0
2971 VERBINST=1
2972
2973 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
2974 -e 'install({@ARGV},"$(VERBINST)",0,"$(UNINST)");'
2975
2976 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
2977 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
2978 -e 'print "=over 4";' \
2979 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
2980 -e 'print "=back";'
2981
2982 UNINSTALL =   $(PERL) -MExtUtils::Install \
2983 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
2984 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
2985 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
2986 };
2987
2988     return join "", @m;
2989 }
2990
2991 =item tool_xsubpp (o)
2992
2993 Determines typemaps, xsubpp version, prototype behaviour.
2994
2995 =cut
2996
2997 sub tool_xsubpp {
2998     my($self) = shift;
2999     return "" unless $self->needs_linking;
3000     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3001     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3002     if( $self->{TYPEMAPS} ){
3003         my $typemap;
3004         foreach $typemap (@{$self->{TYPEMAPS}}){
3005                 if( ! -f  $typemap ){
3006                         warn "Typemap $typemap not found.\n";
3007                 }
3008                 else{
3009                         push(@tmdeps,  $typemap);
3010                 }
3011         }
3012     }
3013     push(@tmdeps, "typemap") if -f "typemap";
3014     my(@tmargs) = map("-typemap $_", @tmdeps);
3015     if( exists $self->{XSOPT} ){
3016         unshift( @tmargs, $self->{XSOPT} );
3017     }
3018
3019
3020     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3021
3022     # What are the correct thresholds for version 1 && 2 Paul?
3023     if ( $xsubpp_version > 1.923 ){
3024         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3025     } else {
3026         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3027             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3028         Your version of xsubpp is $xsubpp_version and cannot handle this.
3029         Please upgrade to a more recent version of xsubpp.
3030 };
3031         } else {
3032             $self->{XSPROTOARG} = "";
3033         }
3034     }
3035
3036     return qq{
3037 XSUBPPDIR = $xsdir
3038 XSUBPP = \$(XSUBPPDIR)/xsubpp
3039 XSPROTOARG = $self->{XSPROTOARG}
3040 XSUBPPDEPS = @tmdeps
3041 XSUBPPARGS = @tmargs
3042 };
3043 };
3044
3045 sub xsubpp_version
3046 {
3047     my($self,$xsubpp) = @_;
3048     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3049
3050     my ($version) ;
3051
3052     # try to figure out the version number of the xsubpp on the system
3053
3054     # first try the -v flag, introduced in 1.921 & 2.000a2
3055
3056     return "" unless $self->needs_linking;
3057
3058     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3059     print "Running $command\n" if $Verbose >= 2;
3060     $version = `$command` ;
3061     warn "Running '$command' exits with status " . ($?>>8) if $?;
3062     chop $version ;
3063
3064     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3065
3066     # nope, then try something else
3067
3068     my $counter = '000';
3069     my ($file) = 'temp' ;
3070     $counter++ while -e "$file$counter"; # don't overwrite anything
3071     $file .= $counter;
3072
3073     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3074     print F <<EOM ;
3075 MODULE = fred PACKAGE = fred
3076
3077 int
3078 fred(a)
3079         int     a;
3080 EOM
3081
3082     close F ;
3083
3084     $command = "$self->{PERL} $xsubpp $file 2>&1";
3085     print "Running $command\n" if $Verbose >= 2;
3086     my $text = `$command` ;
3087     warn "Running '$command' exits with status " . ($?>>8) if $?;
3088     unlink $file ;
3089
3090     # gets 1.2 -> 1.92 and 2.000a1
3091     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3092
3093     # it is either 1.0 or 1.1
3094     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3095
3096     # none of the above, so 1.0
3097     return $Xsubpp_Version = "1.0" ;
3098 }
3099
3100 =item top_targets (o)
3101
3102 Defines the targets all, subdirs, config, and O_FILES
3103
3104 =cut
3105
3106 sub top_targets {
3107 # --- Target Sections ---
3108
3109     my($self) = shift;
3110     my(@m);
3111     push @m, '
3112 #all :: config $(INST_PM) subdirs linkext manifypods
3113
3114 all :: pure_all manifypods
3115         '.$self->{NOECHO}.'$(NOOP)
3116
3117 pure_all :: config pm_to_blib subdirs linkext
3118         '.$self->{NOECHO}.'$(NOOP)
3119
3120 subdirs :: $(MYEXTLIB)
3121         '.$self->{NOECHO}.'$(NOOP)
3122
3123 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3124         '.$self->{NOECHO}.'$(NOOP)
3125
3126 config :: $(INST_ARCHAUTODIR)/.exists
3127         '.$self->{NOECHO}.'$(NOOP)
3128
3129 config :: $(INST_AUTODIR)/.exists
3130         '.$self->{NOECHO}.'$(NOOP)
3131 ';
3132
3133     push @m, qq{
3134 config :: Version_check
3135         $self->{NOECHO}\$(NOOP)
3136
3137 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3138
3139     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3140
3141     if (%{$self->{MAN1PODS}}) {
3142         push @m, qq[
3143 config :: \$(INST_MAN1DIR)/.exists
3144         $self->{NOECHO}\$(NOOP)
3145
3146 ];
3147         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3148     }
3149     if (%{$self->{MAN3PODS}}) {
3150         push @m, qq[
3151 config :: \$(INST_MAN3DIR)/.exists
3152         $self->{NOECHO}\$(NOOP)
3153
3154 ];
3155         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3156     }
3157
3158     push @m, '
3159 $(O_FILES): $(H_FILES)
3160 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3161
3162     push @m, q{
3163 help:
3164         perldoc ExtUtils::MakeMaker
3165 };
3166
3167     push @m, q{
3168 Version_check:
3169         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3170                 -MExtUtils::MakeMaker=Version_check \
3171                 -e 'Version_check("$(MM_VERSION)")'
3172 };
3173
3174     join('',@m);
3175 }
3176
3177 =item writedoc
3178
3179 Obsolete, depecated method. Not used since Version 5.21.
3180
3181 =cut
3182
3183 sub writedoc {
3184 # --- perllocal.pod section ---
3185     my($self,$what,$name,@attribs)=@_;
3186     my $time = localtime;
3187     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3188     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3189     print "\n\n=back\n\n";
3190 }
3191
3192 =item xs_c (o)
3193
3194 Defines the suffix rules to compile XS files to C.
3195
3196 =cut
3197
3198 sub xs_c {
3199     my($self) = shift;
3200     return '' unless $self->needs_linking();
3201     '
3202 .xs.c:
3203         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
3204 ';
3205 }
3206
3207 =item xs_o (o)
3208
3209 Defines suffix rules to go from XS to object files directly. This is
3210 only intended for broken make implementations.
3211
3212 =cut
3213
3214 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3215     my($self) = shift;
3216     return '' unless $self->needs_linking();
3217     '
3218 .xs$(OBJ_EXT):
3219         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
3220         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3221 ';
3222 }
3223
3224 1;
3225
3226 =back
3227
3228 =head1 SEE ALSO
3229
3230 L<ExtUtils::MakeMaker>
3231
3232 =cut
3233
3234 __END__