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