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