lib/ExtUtils/MM_Unix.pm

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