lib/ExtUtils/MM_Unix.pm

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