lib/ExtUtils/MM_Unix.pm

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