lib/ExtUtils/MM_Unix.pm

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