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