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