1 package ExtUtils::MM_Unix;
7 use File::Basename qw(basename dirname fileparse);
10 our ($Is_Mac,$Is_OS2,$Is_VMS,$Is_Win32,$Is_Dos,$Is_PERL_OBJECT,
11 $Verbose,%pm,%static,$Xsubpp_Version);
13 our $VERSION = '1.12603';
15 require ExtUtils::MakeMaker;
16 ExtUtils::MakeMaker->import(qw($Verbose &neatvalue));
18 $Is_OS2 = $^O eq 'os2';
19 $Is_Mac = $^O eq 'MacOS';
20 $Is_Win32 = $^O eq 'MSWin32';
21 $Is_Dos = $^O eq 'dos';
23 $Is_PERL_OBJECT = $Config{'ccflags'} =~ /-DPERL_OBJECT/;
25 if ($Is_VMS = $^O eq 'VMS') {
26 require VMS::Filespec;
27 import VMS::Filespec qw( &vmsify );
32 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
36 C<require ExtUtils::MM_Unix;>
40 The methods provided by this package are designed to be used in
41 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
42 Makefile, it creates one or more objects that inherit their methods
43 from a package C<MM>. MM itself doesn't provide any methods, but it
44 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
45 specific packages take the responsibility for all the methods provided
46 by MM_Unix. We are trying to reduce the number of the necessary
47 overrides by defining rather primitive operations within
50 If you are going to write a platform specific MM package, please try
51 to limit the necessary overrides to primitive methods, and if it is not
52 possible to do so, let's work out how to achieve that gain.
54 If you are overriding any of these methods in your Makefile.PL (in the
55 MY class), please report that to the makemaker mailing list. We are
56 trying to minimize the necessary method overrides and switch to data
57 driven Makefile.PLs wherever possible. In the long run less methods
58 will be overridable via the MY class.
62 The following description of methods is still under
63 development. Please refer to the code for not suitably documented
64 sections and complain loudly to the makemaker mailing list.
66 Not all of the methods below are overridable in a
67 Makefile.PL. Overridable methods are marked as (o). All methods are
68 overridable by a platform specific MM_*.pm file (See
69 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
71 =head2 Preloaded methods
77 No physical check on the filesystem, but a logical cleanup of a
78 path. On UNIX eliminated successive slashes and successive "/.".
85 if ( $^O eq 'qnx' && $path =~ s|^(//\d+)/|/|s ) {
88 $path =~ s|(?<=[^/])/+|/|g ; # xx////xx -> xx/xx
89 $path =~ s|(/\.)+/|/|g ; # xx/././xx -> xx/xx
90 $path =~ s|^(\./)+||s unless $path eq "./"; # ./xx -> xx
91 $path =~ s|(?<=[^/])/\z|| ; # xx/ -> xx
97 Concatenate two or more directory names to form a complete path ending
98 with a directory. But remove the trailing slash from the resulting
99 string, because it doesn't look good, isn't necessary and confuses
100 OS2. Of course, if this is the root directory, don't cut off the
111 # append a slash to each argument unless it has one there
112 $_ .= "/" if $_ eq '' or substr($_,-1) ne "/";
114 $self->canonpath(join('', @args));
119 Concatenate one or more directory names and a filename to form a
120 complete path ending with a filename
127 return $self->canonpath($file) unless @_;
128 my $dir = $self->catdir(@_);
130 $_ .= "/" unless substr($_,length($_)-1,1) eq "/";
132 return $self->canonpath($dir.$file);
137 Returns a string representing of the current directory. "." on UNIX.
147 Returns a string representing of the root directory. "/" on UNIX.
157 Returns a string representing of the parent directory. ".." on UNIX.
165 sub ExtUtils::MM_Unix::c_o ;
166 sub ExtUtils::MM_Unix::clean ;
167 sub ExtUtils::MM_Unix::const_cccmd ;
168 sub ExtUtils::MM_Unix::const_config ;
169 sub ExtUtils::MM_Unix::const_loadlibs ;
170 sub ExtUtils::MM_Unix::constants ;
171 sub ExtUtils::MM_Unix::depend ;
172 sub ExtUtils::MM_Unix::dir_target ;
173 sub ExtUtils::MM_Unix::dist ;
174 sub ExtUtils::MM_Unix::dist_basics ;
175 sub ExtUtils::MM_Unix::dist_ci ;
176 sub ExtUtils::MM_Unix::dist_core ;
177 sub ExtUtils::MM_Unix::dist_dir ;
178 sub ExtUtils::MM_Unix::dist_test ;
179 sub ExtUtils::MM_Unix::dlsyms ;
180 sub ExtUtils::MM_Unix::dynamic ;
181 sub ExtUtils::MM_Unix::dynamic_bs ;
182 sub ExtUtils::MM_Unix::dynamic_lib ;
183 sub ExtUtils::MM_Unix::exescan ;
184 sub ExtUtils::MM_Unix::export_list ;
185 sub ExtUtils::MM_Unix::extliblist ;
186 sub ExtUtils::MM_Unix::file_name_is_absolute ;
187 sub ExtUtils::MM_Unix::find_perl ;
188 sub ExtUtils::MM_Unix::fixin ;
189 sub ExtUtils::MM_Unix::force ;
190 sub ExtUtils::MM_Unix::guess_name ;
191 sub ExtUtils::MM_Unix::has_link_code ;
192 sub ExtUtils::MM_Unix::htmlifypods ;
193 sub ExtUtils::MM_Unix::init_dirscan ;
194 sub ExtUtils::MM_Unix::init_main ;
195 sub ExtUtils::MM_Unix::init_others ;
196 sub ExtUtils::MM_Unix::install ;
197 sub ExtUtils::MM_Unix::installbin ;
198 sub ExtUtils::MM_Unix::libscan ;
199 sub ExtUtils::MM_Unix::linkext ;
200 sub ExtUtils::MM_Unix::lsdir ;
201 sub ExtUtils::MM_Unix::macro ;
202 sub ExtUtils::MM_Unix::makeaperl ;
203 sub ExtUtils::MM_Unix::makefile ;
204 sub ExtUtils::MM_Unix::manifypods ;
205 sub ExtUtils::MM_Unix::maybe_command ;
206 sub ExtUtils::MM_Unix::maybe_command_in_dirs ;
207 sub ExtUtils::MM_Unix::needs_linking ;
208 sub ExtUtils::MM_Unix::nicetext ;
209 sub ExtUtils::MM_Unix::parse_version ;
210 sub ExtUtils::MM_Unix::pasthru ;
211 sub ExtUtils::MM_Unix::path ;
212 sub ExtUtils::MM_Unix::perl_archive;
213 sub ExtUtils::MM_Unix::perl_archive_after;
214 sub ExtUtils::MM_Unix::perl_script ;
215 sub ExtUtils::MM_Unix::perldepend ;
216 sub ExtUtils::MM_Unix::pm_to_blib ;
217 sub ExtUtils::MM_Unix::post_constants ;
218 sub ExtUtils::MM_Unix::post_initialize ;
219 sub ExtUtils::MM_Unix::postamble ;
220 sub ExtUtils::MM_Unix::ppd ;
221 sub ExtUtils::MM_Unix::prefixify ;
222 sub ExtUtils::MM_Unix::processPL ;
223 sub ExtUtils::MM_Unix::realclean ;
224 sub ExtUtils::MM_Unix::replace_manpage_separator ;
225 sub ExtUtils::MM_Unix::static ;
226 sub ExtUtils::MM_Unix::static_lib ;
227 sub ExtUtils::MM_Unix::staticmake ;
228 sub ExtUtils::MM_Unix::subdir_x ;
229 sub ExtUtils::MM_Unix::subdirs ;
230 sub ExtUtils::MM_Unix::test ;
231 sub ExtUtils::MM_Unix::test_via_harness ;
232 sub ExtUtils::MM_Unix::test_via_script ;
233 sub ExtUtils::MM_Unix::tool_autosplit ;
234 sub ExtUtils::MM_Unix::tool_xsubpp ;
235 sub ExtUtils::MM_Unix::tools_other ;
236 sub ExtUtils::MM_Unix::top_targets ;
237 sub ExtUtils::MM_Unix::writedoc ;
238 sub ExtUtils::MM_Unix::xs_c ;
239 sub ExtUtils::MM_Unix::xs_cpp ;
240 sub ExtUtils::MM_Unix::xs_o ;
241 sub ExtUtils::MM_Unix::xsubpp_version ;
243 package ExtUtils::MM_Unix;
253 =head2 SelfLoaded methods
259 Defines the suffix rules to compile different flavors of C files to
265 # --- Translation Sections ---
268 return '' unless $self->needs_linking();
270 if (my $cpp = $Config{cpprun}) {
271 my $cpp_cmd = $self->const_cccmd;
272 $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/$cpp/;
275 '. $cpp_cmd . ' $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c > $*.i
280 $(CCCMD) -S $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
284 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
288 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
289 ' if $^O ne 'os2' and $^O ne 'MSWin32' and $^O ne 'dos'; #Case-specific
292 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
295 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
298 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
305 Does very much the same as the cflags script in the perl
306 distribution. It doesn't return the whole compiler command line, but
307 initializes all of its parts. The const_cccmd method then actually
308 returns the definition of the CCCMD macro which uses these parts.
315 my($self,$libperl)=@_;
316 return $self->{CFLAGS} if $self->{CFLAGS};
317 return '' unless $self->needs_linking();
319 my($prog, $uc, $perltype, %cflags);
320 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
321 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
323 @cflags{qw(cc ccflags optimize shellflags)}
324 = @Config{qw(cc ccflags optimize shellflags)};
327 $cflags{shellflags} ||= '';
332 DE => '-DDEBUGGING -DEMBED',
333 M => '-DEMBED -DMULTIPLICITY',
334 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
337 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
340 $uc = ""; # avoid warning
342 $perltype = $map{$uc} ? $map{$uc} : "";
350 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
351 if ($prog = $Config::Config{$name}) {
352 # Expand hints for this extension via the shell
353 print STDOUT "Processing $name hint:\n" if $Verbose;
354 my(@o)=`cc=\"$cflags{cc}\"
355 ccflags=\"$cflags{ccflags}\"
356 optimize=\"$cflags{optimize}\"
357 perltype=\"$cflags{perltype}\"
358 optdebug=\"$cflags{optdebug}\"
361 echo ccflags=\$ccflags
362 echo optimize=\$optimize
363 echo perltype=\$perltype
364 echo optdebug=\$optdebug
369 if ($line =~ /(.*?)=\s*(.*)\s*$/){
371 print STDOUT " $1 = $2\n" if $Verbose;
373 print STDOUT "Unrecognised result from hint: '$line'\n";
379 $cflags{optimize} = $optdebug;
382 for (qw(ccflags optimize perltype)) {
383 $cflags{$_} =~ s/^\s+//;
384 $cflags{$_} =~ s/\s+/ /g;
385 $cflags{$_} =~ s/\s+$//;
386 $self->{uc $_} ||= $cflags{$_}
389 if ($Is_PERL_OBJECT) {
390 $self->{CCFLAGS} =~ s/-DPERL_OBJECT(\b|$)/-DPERL_CAPI/g;
392 if ($Config{'cc'} =~ /^cl/i) {
393 # Turn off C++ mode of the MSC compiler
394 $self->{CCFLAGS} =~ s/-TP(\s|$)//g;
395 $self->{OPTIMIZE} =~ s/-TP(\s|$)//g;
397 elsif ($Config{'cc'} =~ /^bcc32/i) {
398 # Turn off C++ mode of the Borland compiler
399 $self->{CCFLAGS} =~ s/-P(\s|$)//g;
400 $self->{OPTIMIZE} =~ s/-P(\s|$)//g;
402 elsif ($Config{'cc'} =~ /^gcc/i) {
403 # Turn off C++ mode of the GCC compiler
404 $self->{CCFLAGS} =~ s/-xc\+\+(\s|$)//g;
405 $self->{OPTIMIZE} =~ s/-xc\+\+(\s|$)//g;
410 if ($self->{POLLUTE}) {
411 $self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
415 if ($Config{usemymalloc} and not $Config{bincompat5005}
416 and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
417 and $self->{PERL_MALLOC_OK}) {
418 $pollute = '$(PERL_MALLOC_DEF)';
421 return $self->{CFLAGS} = qq{
422 CCFLAGS = $self->{CCFLAGS}
423 OPTIMIZE = $self->{OPTIMIZE}
424 PERLTYPE = $self->{PERLTYPE}
432 Defines the clean target.
437 # --- Cleanup and Distribution Sections ---
439 my($self, %attribs) = @_;
442 # Delete temporary files but do not touch installed files. We don\'t delete
443 # the Makefile here so a later make realclean still has a makefile to use.
447 # clean subdirectories first
448 for $dir (@{$self->{DIR}}) {
449 if ($Is_Win32 && Win32::IsWin95()) {
452 \$(TEST_F) $self->{MAKEFILE}
459 -cd $dir && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) clean
464 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
465 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
466 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
467 perlmain.c tmon.out mon.out core core.*perl.*.?
468 *perl.core so_locations pm_to_blib
469 *$(OBJ_EXT) *$(LIB_EXT) perl.exe
470 $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
473 push @m, "\t-$self->{RM_RF} @otherfiles\n";
474 # See realclean and ext/utils/make_ext for usage of Makefile.old
476 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
478 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
482 =item const_cccmd (o)
484 Returns the full compiler call for C programs and stores the
485 definition in CONST_CCCMD.
490 my($self,$libperl)=@_;
491 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
492 return '' unless $self->needs_linking();
493 return $self->{CONST_CCCMD} =
494 q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
495 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
496 $(XS_DEFINE_VERSION)};
499 =item const_config (o)
501 Defines a couple of constants in the Makefile that are imported from
507 # --- Constants Sections ---
511 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
512 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
514 foreach $m (@{$self->{CONFIG}}){
515 # SITE*EXP macros are defined in &constants; avoid duplicates here
516 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
517 push @m, "\U$m\E = ".$self->{uc $m}."\n";
523 =item const_loadlibs (o)
525 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
526 L<ExtUtils::Liblist> for details.
532 return "" unless $self->needs_linking;
535 # $self->{NAME} might depend on some other libraries:
536 # See ExtUtils::Liblist for details
541 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
543 next unless defined $self->{$tmp};
544 push @m, "$tmp = $self->{$tmp}\n";
551 Initializes lots of constants and .SUFFIXES and .PHONY
561 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
562 VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
563 INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
564 INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
565 INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
566 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
567 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
568 PERL_INC PERL FULLPERL FULL_AR
571 next unless defined $self->{$tmp};
572 push @m, "$tmp = $self->{$tmp}\n";
576 VERSION_MACRO = VERSION
577 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
578 XS_VERSION_MACRO = XS_VERSION
579 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
580 PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc
584 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
585 MM_VERSION = $ExtUtils::MakeMaker::VERSION
589 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
590 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
591 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD) !!! Deprecated from MM 5.32 !!!
592 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
593 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
597 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
598 LDFROM LINKTYPE PM_FILTER
600 next unless defined $self->{$tmp};
601 push @m, "$tmp = $self->{$tmp}\n";
605 # Handy lists of source code files:
606 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
607 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
608 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
609 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
610 HTMLLIBPODS = ".join(" \\\n\t", sort keys %{$self->{HTMLLIBPODS}})."
611 HTMLSCRIPTPODS = ".join(" \\\n\t", sort keys %{$self->{HTMLSCRIPTPODS}})."
612 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
613 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
617 INST_HTMLPRIVLIBDIR INSTALLHTMLPRIVLIBDIR
618 INST_HTMLSITELIBDIR INSTALLHTMLSITELIBDIR
619 INST_HTMLSCRIPTDIR INSTALLHTMLSCRIPTDIR
620 INST_HTMLLIBDIR HTMLEXT
621 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT
622 INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
624 next unless defined $self->{$tmp};
625 push @m, "$tmp = $self->{$tmp}\n";
632 my $method = lc($tmp);
633 # warn "self[$self] method[$method]";
634 push @m, "$tmp = ", $self->$method(), "\n";
638 .NO_CONFIG_REC: Makefile
639 } if $ENV{CLEARCASE_ROOT};
641 # why not q{} ? -- emacs
643 # work around a famous dec-osf make(1) feature(?):
646 .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc \$(OBJ_EXT)
648 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
649 # some make implementations will delete the Makefile when we rebuild it. Because
650 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
651 # does so. Our milage may vary.
652 # .PRECIOUS: Makefile # seems to be not necessary anymore
654 .PHONY: all config static dynamic test linkext manifest
656 # Where is the Config information that we are using/depend on
657 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
660 my @parentdir = split(/::/, $self->{PARENT_NAME});
662 # Where to put things:
663 INST_LIBDIR = }. $self->catdir('$(INST_LIB)',@parentdir) .q{
664 INST_ARCHLIBDIR = }. $self->catdir('$(INST_ARCHLIB)',@parentdir) .q{
666 INST_AUTODIR = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
667 INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
670 if ($self->has_link_code()) {
672 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
673 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
674 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
684 $tmp = $self->export_list;
688 $tmp = $self->perl_archive;
692 $tmp = $self->perl_archive_after;
694 PERL_ARCHIVE_AFTER = $tmp
698 #INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
700 #PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
704 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
706 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
714 Same as macro for the depend attribute.
719 my($self,%attribs) = @_;
721 while (($key,$val) = each %attribs){
722 last unless defined $key;
723 push @m, "$key: $val\n";
730 Takes an array of directories that need to exist and returns a
731 Makefile entry for a .exists file in these directories. Returns
732 nothing, if the entry has already been processed. We're helpless
733 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
734 them get an entry, that's why we use "::".
739 # --- Make-Directories section (internal method) ---
740 # dir_target(@array) returns a Makefile entry for the file .exists in each
741 # named directory. Returns nothing, if the entry has already been processed.
742 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
743 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
744 # prerequisite, because there has to be one, something that doesn't change
747 my($self,@dirs) = @_;
748 my(@m,$dir,$targdir);
749 foreach $dir (@dirs) {
750 my($src) = $self->catfile($self->{PERL_INC},'perl.h');
751 my($targ) = $self->catfile($dir,'.exists');
752 # catfile may have adapted syntax of $dir to target OS, so...
753 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
754 ($targdir = $targ) =~ s:/?\.exists\z::;
756 else { # while elsewhere we expect to see the dir separator in $targ
757 $targdir = dirname($targ);
759 next if $self->{DIR_TARGET}{$self}{$targdir}++;
762 $self->{NOECHO}\$(MKPATH) $targdir
763 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
766 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $targdir
774 Defines a lot of macros for distribution support.
779 my($self, %attribs) = @_;
782 # VERSION should be sanitised before use as a file name
783 my($version) = $attribs{VERSION} || '$(VERSION)';
784 my($name) = $attribs{NAME} || '$(DISTNAME)';
785 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
786 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
787 my($zip) = $attribs{ZIP} || 'zip'; # eg pkzip Yuck!
788 my($zipflags) = $attribs{ZIPFLAGS} || '-r';
789 my($compress) = $attribs{COMPRESS} || 'gzip --best';
790 my($suffix) = $attribs{SUFFIX} || '.gz'; # eg .gz
791 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
792 my($preop) = $attribs{PREOP} || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
793 my($postop) = $attribs{POSTOP} || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
795 my($to_unix) = $attribs{TO_UNIX} || ($Is_OS2
797 . '$(TEST_F) tmp.zip && $(RM) tmp.zip;'
798 . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
799 : "$self->{NOECHO}\$(NOOP)");
801 my($ci) = $attribs{CI} || 'ci -u';
802 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
803 my($dist_cp) = $attribs{DIST_CP} || 'best';
804 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
807 DISTVNAME = ${name}-$version
819 RCS_LABEL = $rcs_label
821 DIST_DEFAULT = $dist_default
826 =item dist_basics (o)
828 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
836 distclean :: realclean distcheck
841 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \\
847 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \\
853 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \\
858 veryclean : realclean
859 $(RM_F) *~ *.orig */*~ */*.orig
866 Defines a check in target for RCS.
875 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \\
876 -e "@all = keys %{ maniread() };" \\
877 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
878 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
885 Defines the targets dist, tardist, zipdist, uutardist, shdist
893 dist : $(DIST_DEFAULT)
894 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
895 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
897 tardist : $(DISTVNAME).tar$(SUFFIX)
899 zipdist : $(DISTVNAME).zip
901 $(DISTVNAME).tar$(SUFFIX) : distdir
904 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
905 $(RM_RF) $(DISTVNAME)
906 $(COMPRESS) $(DISTVNAME).tar
909 $(DISTVNAME).zip : distdir
911 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
912 $(RM_RF) $(DISTVNAME)
915 uutardist : $(DISTVNAME).tar$(SUFFIX)
916 uuencode $(DISTVNAME).tar$(SUFFIX) \\
917 $(DISTVNAME).tar$(SUFFIX) > \\
918 $(DISTVNAME).tar$(SUFFIX)_uu
922 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
923 $(RM_RF) $(DISTVNAME)
931 Defines the scratch directory target that will hold the distribution
932 before tar-ing (or shar-ing).
941 $(RM_RF) $(DISTVNAME)
942 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
943 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
950 Defines a target that produces the distribution in the
951 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
961 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
962 cd $(DISTVNAME) && $(MAKE)
963 cd $(DISTVNAME) && $(MAKE) test
970 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
976 my($self,%attribs) = @_;
978 return '' unless ($^O eq 'aix' && $self->needs_linking() );
980 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
981 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
982 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
986 dynamic :: $self->{BASEEXT}.exp
988 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
991 static :: $self->{BASEEXT}.exp
993 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
996 $self->{BASEEXT}.exp: Makefile.PL
997 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
998 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
999 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
1000 ', "DL_VARS" => ', neatvalue($vars), ');\'
1008 Defines the dynamic target.
1013 # --- Dynamic Loading Sections ---
1017 ## $(INST_PM) has been moved to the all: target.
1018 ## It remains here for awhile to allow for old usage: "make dynamic"
1019 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
1020 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
1021 '.$self->{NOECHO}.'$(NOOP)
1025 =item dynamic_bs (o)
1027 Defines targets for bootstrap files.
1032 my($self, %attribs) = @_;
1035 ' unless $self->has_link_code();
1038 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
1040 # As Mkbootstrap might not write a file (if none is required)
1041 # we use touch to prevent make continually trying to remake it.
1042 # The DynaLoader only reads a non-empty file.
1043 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
1044 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1045 '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
1046 -MExtUtils::Mkbootstrap \
1047 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
1048 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
1049 $(CHMOD) $(PERM_RW) $@
1051 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
1052 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
1053 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
1054 $(CHMOD) $(PERM_RW) $@
1058 =item dynamic_lib (o)
1060 Defines how to produce the *.so (or equivalent) files.
1065 my($self, %attribs) = @_;
1066 return '' unless $self->needs_linking(); #might be because of a subdir
1068 return '' unless $self->has_link_code;
1070 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1071 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1072 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1073 my($ldfrom) = '$(LDFROM)';
1074 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
1077 # This section creates the dynamically loadable $(INST_DYNAMIC)
1078 # from $(OBJECT) and possibly $(MYEXTLIB).
1079 ARMAYBE = '.$armaybe.'
1080 OTHERLDFLAGS = '.$otherldflags.'
1081 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1083 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
1085 if ($armaybe ne ':'){
1086 $ldfrom = 'tmp$(LIB_EXT)';
1087 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1088 push(@m,' $(RANLIB) '."$ldfrom\n");
1090 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1092 # The IRIX linker doesn't use LD_RUN_PATH
1093 my $ldrun = qq{-rpath "$self->{LD_RUN_PATH}"}
1094 if ($^O eq 'irix' && $self->{LD_RUN_PATH});
1096 # For example in AIX the shared objects/libraries from previous builds
1097 # linger quite a while in the shared dynalinker cache even when nobody
1098 # is using them. This is painful if one for instance tries to restart
1099 # a failed build because the link command will fail unnecessarily 'cos
1100 # the shared object/library is 'busy'.
1101 push(@m,' $(RM_F) $@
1104 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1105 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST)');
1107 $(CHMOD) $(PERM_RWX) $@
1110 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1116 Deprecated method. Use libscan instead.
1121 my($self,$path) = @_;
1127 Called by init_others, and calls ext ExtUtils::Liblist. See
1128 L<ExtUtils::Liblist> for details.
1133 my($self,$libs) = @_;
1134 require ExtUtils::Liblist;
1135 $self->ext($libs, $Verbose);
1138 =item file_name_is_absolute
1140 Takes as argument a path and returns true, if it is an absolute path.
1144 sub file_name_is_absolute {
1145 my($self,$file) = @_;
1147 $file =~ m{^([a-z]:)?[\\/]}is ;
1156 Finds the executables PERL and FULLPERL
1161 my($self, $ver, $names, $dirs, $trace) = @_;
1164 print "Looking for perl $ver by these names:
1170 foreach $name (@$names){
1171 foreach $dir (@$dirs){
1172 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1174 if ($self->file_name_is_absolute($name)) { # /foo/bar
1176 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1177 $abs = $self->catfile($dir, $name);
1179 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1181 print "Checking $abs\n" if ($trace >= 2);
1182 next unless $self->maybe_command($abs);
1183 print "Executing $abs\n" if ($trace >= 2);
1184 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1185 if ($val =~ /VER_OK/) {
1186 print "Using PERL=$abs\n" if $trace;
1188 } elsif ($trace >= 2) {
1189 print "Result: `$val'\n";
1193 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1194 0; # false and not empty
1199 =head2 Methods to actually produce chunks of text for the Makefile
1201 The methods here are called for each MakeMaker object in the order
1202 specified by @ExtUtils::MakeMaker::MM_Sections.
1208 Inserts the sharpbang or equivalent magic number to a script
1212 sub fixin { # stolen from the pink Camel book, more or less
1213 my($self,@files) = @_;
1214 my($does_shbang) = $Config::Config{'sharpbang'} =~ /^\s*\#\!/;
1215 my($file,$interpreter);
1216 for $file (@files) {
1219 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1221 chomp(my $line = <FIXIN>);
1222 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1223 # Now figure out the interpreter name.
1224 my($cmd,$arg) = split ' ', $line, 2;
1227 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1228 if ($cmd eq "perl") {
1229 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1230 $interpreter = $Config{startperl};
1231 $interpreter =~ s,^\#!,,;
1233 $interpreter = $Config{perlpath};
1236 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1239 foreach $dir (@absdirs) {
1240 if ($self->maybe_command($cmd)) {
1241 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1242 $interpreter = $self->catfile($dir,$cmd);
1246 # Figure out how to invoke interpreter on this machine.
1250 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1251 # this is probably value-free on DOSISH platforms
1253 $shb .= "$Config{'sharpbang'}$interpreter";
1254 $shb .= ' ' . $arg if defined $arg;
1258 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1259 if 0; # not running under some shell
1260 } unless $Is_Win32; # this won't work on win32, so don't
1262 warn "Can't find $cmd in PATH, $file unchanged"
1267 unless ( open(FIXOUT,">$file.new") ) {
1268 warn "Can't create new $file: $!\n";
1271 my($dev,$ino,$mode) = stat FIXIN;
1273 # Print out the new #! line (or equivalent).
1276 print FIXOUT $shb, <FIXIN>;
1280 # can't rename/chmod open files on some DOSISH platforms
1282 # If they override perm_rwx, we won't notice it during fixin,
1283 # because fixin is run through a new instance of MakeMaker.
1284 # That is why we must run another CHMOD later.
1285 $mode = oct($self->perm_rwx) unless $dev;
1288 unless ( rename($file, "$file.bak") ) {
1289 warn "Can't rename $file to $file.bak: $!";
1292 unless ( rename("$file.new", $file) ) {
1293 warn "Can't rename $file.new to $file: $!";
1294 unless ( rename("$file.bak", $file) ) {
1295 warn "Can't rename $file.bak back to $file either: $!";
1296 warn "Leaving $file renamed as $file.bak\n";
1302 close(FIXIN) if fileno(FIXIN);
1303 chmod oct($self->perm_rwx), $file or
1304 die "Can't reset permissions for $file: $!\n";
1305 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1317 '# Phony target to force checking subdirectories.
1319 '.$self->{NOECHO}.'$(NOOP)
1325 Guess the name of this package by examining the working directory's
1326 name. MakeMaker calls this only if the developer has not supplied a
1336 my $name = basename(cwd());
1337 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1338 # strip minus or underline
1339 # followed by a float or some such
1340 print "Warning: Guessing NAME [$name] from current directory name.\n";
1346 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1347 object that need a compiler. Does not descend into subdirectories as
1348 needs_linking() does.
1354 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1355 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1356 $self->{HAS_LINK_CODE} = 1;
1359 return $self->{HAS_LINK_CODE} = 0;
1362 =item htmlifypods (o)
1364 Defines targets and routines to translate the pods into HTML manpages
1365 and put them into the INST_HTMLLIBDIR and INST_HTMLSCRIPTDIR
1371 my($self, %attribs) = @_;
1372 return "\nhtmlifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
1373 %{$self->{HTMLLIBPODS}} || %{$self->{HTMLSCRIPTPODS}};
1376 if (defined $self->{PERL_SRC}) {
1377 $pod2html_exe = $self->catfile($self->{PERL_SRC},'pod','pod2html');
1379 $pod2html_exe = $self->catfile($Config{scriptdirexp},'pod2html');
1381 unless ($pod2html_exe = $self->perl_script($pod2html_exe)) {
1382 # No pod2html but some HTMLxxxPODS to be installed
1385 Warning: I could not locate your pod2html program. Please make sure,
1386 your pod2html program is in your PATH before you execute 'make'
1389 $pod2html_exe = "-S pod2html";
1393 qq[POD2HTML_EXE = $pod2html_exe\n],
1394 qq[POD2HTML = \$(PERL) -we 'use File::Basename; use File::Path qw(mkpath); %m=\@ARGV;for (keys %m){' \\\n],
1395 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
1396 $self->{MAKEFILE}, q[";' \\
1397 -e 'print "Htmlifying $$m{$$_}\n";' \\
1398 -e '$$dir = dirname($$m{$$_}); mkpath($$dir) unless -d $$dir;' \\
1399 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2HTML_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
1400 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
1402 push @m, "\nhtmlifypods : pure_all ";
1403 push @m, join " \\\n\t", keys %{$self->{HTMLLIBPODS}}, keys %{$self->{HTMLSCRIPTPODS}};
1406 if (%{$self->{HTMLLIBPODS}} || %{$self->{HTMLSCRIPTPODS}}) {
1407 push @m, "\t$self->{NOECHO}\$(POD2HTML) \\\n\t";
1408 push @m, join " \\\n\t", %{$self->{HTMLLIBPODS}}, %{$self->{HTMLSCRIPTPODS}};
1415 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, HTML*PODS, MAN*PODS, EXE_FILES.
1419 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1421 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1422 local(%pm); #the sub in find() has to see this hash
1423 @ignore{qw(Makefile.PL test.pl)} = (1,1);
1424 $ignore{'makefile.pl'} = 1 if $Is_VMS;
1425 foreach $name ($self->lsdir($self->curdir)){
1426 next if $name =~ /\#/;
1427 next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1428 next unless $self->libscan($name);
1430 next if -l $name; # We do not support symlinks at all
1431 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1432 } elsif ($name =~ /\.xs\z/){
1433 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1436 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1438 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1439 } elsif ($name =~ /\.h\z/i){
1441 } elsif ($name =~ /\.PL\z/) {
1442 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1443 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1444 # case-insensitive filesystem, one dot per name, so foo.h.PL
1445 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1446 local($/); open(PL,$name); my $txt = <PL>; close PL;
1447 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1448 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1450 else { $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name); }
1451 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1452 $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1456 # Some larger extensions often wish to install a number of *.pm/pl
1457 # files into the library in various locations.
1459 # The attribute PMLIBDIRS holds an array reference which lists
1460 # subdirectories which we should search for library files to
1461 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1462 # recursively search through the named directories (skipping any
1463 # which don't exist or contain Makefile.PL files).
1465 # For each *.pm or *.pl file found $self->libscan() is called with
1466 # the default installation path in $_[1]. The return value of
1467 # libscan defines the actual installation location. The default
1468 # libscan function simply returns the path. The file is skipped
1469 # if libscan returns false.
1471 # The default installation location passed to libscan in $_[1] is:
1473 # ./*.pm => $(INST_LIBDIR)/*.pm
1474 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1475 # ./lib/... => $(INST_LIB)/...
1477 # In this way the 'lib' directory is seen as the root of the actual
1478 # perl library whereas the others are relative to INST_LIBDIR
1479 # (which includes PARENT_NAME). This is a subtle distinction but one
1480 # that's important for nested modules.
1482 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1483 unless $self->{PMLIBDIRS};
1485 #only existing directories that aren't in $dir are allowed
1487 # Avoid $_ wherever possible:
1488 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1489 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1491 @{$self->{PMLIBDIRS}} = ();
1492 foreach $pmlibdir (@pmlibdirs) {
1493 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1496 if (@{$self->{PMLIBDIRS}}){
1497 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1500 File::Find::find(sub {
1502 if ($_ eq "CVS" || $_ eq "RCS"){
1503 $File::Find::prune = 1;
1508 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1509 my($striplibpath,$striplibname);
1510 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1511 ($striplibname,$striplibpath) = fileparse($striplibpath);
1512 my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1513 local($_) = $inst; # for backwards compatibility
1514 $inst = $self->libscan($inst);
1515 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1516 return unless $inst;
1518 }, @{$self->{PMLIBDIRS}});
1521 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1522 $self->{XS} = \%xs unless $self->{XS};
1523 $self->{PM} = \%pm unless $self->{PM};
1524 $self->{C} = [sort keys %c] unless $self->{C};
1525 my(@o_files) = @{$self->{C}};
1526 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files] ;
1527 $self->{H} = [sort keys %h] unless $self->{H};
1528 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1530 # Set up names of manual pages to generate from pods
1532 foreach my $man (qw(MAN1 MAN3 HTMLLIB HTMLSCRIPT)) {
1533 unless ($self->{"${man}PODS"}) {
1534 $self->{"${man}PODS"} = {};
1535 $pods{$man} = 1 unless $self->{"INST_${man}DIR"} =~ /^(none|\s*)$/;
1539 if ($pods{MAN1} || $pods{HTMLSCRIPT}) {
1540 if ( exists $self->{EXE_FILES} ) {
1541 foreach $name (@{$self->{EXE_FILES}}) {
1544 if (open(FH,"<$name")) {
1546 if (/^=head1\s+\w+/) {
1553 # If it doesn't exist yet, we assume, it has pods in it
1557 if ($pods{HTMLSCRIPT}) {
1558 $self->{HTMLSCRIPTPODS}->{$name} =
1559 $self->catfile("\$(INST_HTMLSCRIPTDIR)", basename($name).".\$(HTMLEXT)");
1562 $self->{MAN1PODS}->{$name} =
1563 $self->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1568 if ($pods{MAN3} || $pods{HTMLLIB}) {
1569 my %manifypods = (); # we collect the keys first, i.e. the files
1570 # we have to convert to pod
1571 foreach $name (keys %{$self->{PM}}) {
1572 if ($name =~ /\.pod\z/ ) {
1573 $manifypods{$name} = $self->{PM}{$name};
1574 } elsif ($name =~ /\.p[ml]\z/ ) {
1577 if (open(FH,"<$name")) {
1579 if (/^=head1\s+\w+/) {
1589 $manifypods{$name} = $self->{PM}{$name};
1594 # Remove "Configure.pm" and similar, if it's not the only pod listed
1595 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1596 foreach $name (keys %manifypods) {
1597 if ($name =~ /(config|setup).*\.pm/is) {
1598 delete $manifypods{$name};
1601 my($manpagename) = $name;
1602 $manpagename =~ s/\.p(od|m|l)\z//;
1603 if ($pods{HTMLLIB}) {
1604 $self->{HTMLLIBPODS}->{$name} =
1605 $self->catfile("\$(INST_HTMLLIBDIR)", "$manpagename.\$(HTMLEXT)");
1607 unless ($manpagename =~ s!^\W*lib\W+!!s) { # everything below lib is ok
1608 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1611 $manpagename = $self->replace_manpage_separator($manpagename);
1612 $self->{MAN3PODS}->{$name} =
1613 $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1621 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1622 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1623 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1624 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1631 # --- Initialize Module Name and Paths
1633 # NAME = Foo::Bar::Oracle
1634 # FULLEXT = Foo/Bar/Oracle
1636 # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1637 # PARENT_NAME = Foo::Bar
1639 ### ($self->{FULLEXT} =
1640 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1641 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1644 # Copied from DynaLoader:
1646 my(@modparts) = split(/::/,$self->{NAME});
1647 my($modfname) = $modparts[-1];
1649 # Some systems have restrictions on files names for DLL's etc.
1650 # mod2fname returns appropriate file base name (typically truncated)
1651 # It may also edit @modparts if required.
1652 if (defined &DynaLoader::mod2fname) {
1653 $modfname = &DynaLoader::mod2fname(\@modparts);
1656 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1658 if (defined &DynaLoader::mod2fname) {
1659 # As of 5.001m, dl_os2 appends '_'
1660 $self->{DLBASE} = $modfname;
1662 $self->{DLBASE} = '$(BASEEXT)';
1666 ### ROOTEXT deprecated from MM 5.32
1667 ### ($self->{ROOTEXT} =
1668 ### $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
1669 ### $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1672 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1674 # *Real* information: where did we get these two from? ...
1675 my $inc_config_dir = dirname($INC{'Config.pm'});
1676 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1678 unless ($self->{PERL_SRC}){
1680 foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir(),$self->updir())){
1682 -f $self->catfile($dir,"config.sh")
1684 -f $self->catfile($dir,"perl.h")
1686 -f $self->catfile($dir,"lib","Exporter.pm")
1688 $self->{PERL_SRC}=$dir ;
1693 if ($self->{PERL_SRC}){
1694 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1695 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1696 $self->{PERL_INC} = ($Is_Win32) ? $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1698 # catch a situation that has occurred a few times in the past:
1700 -s $self->catfile($self->{PERL_SRC},'cflags')
1704 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1711 You cannot build extensions below the perl source tree after executing
1712 a 'make clean' in the perl source tree.
1714 To rebuild extensions distributed with the perl source you should
1715 simply Configure (to include those extensions) and then build perl as
1716 normal. After installing perl the source tree can be deleted. It is
1717 not needed for building extensions by running 'perl Makefile.PL'
1718 usually without extra arguments.
1720 It is recommended that you unpack and build additional extensions away
1721 from the perl source tree.
1725 # we should also consider $ENV{PERL5LIB} here
1726 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1727 $self->{PERL_LIB} ||= $Config::Config{privlibexp};
1728 $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1729 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1732 no warnings 'uninitialized' ;
1733 if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
1735 # Maybe somebody tries to build an extension with an
1736 # uninstalled Perl outside of Perl build tree
1738 for my $dir (@INC) {
1739 $found = $dir, last if -e $self->catdir($dir, "Config.pm");
1742 my $inc = dirname $found;
1743 if (-e $self->catdir($inc, "perl.h")) {
1744 $self->{PERL_LIB} = $found;
1745 $self->{PERL_ARCHLIB} = $found;
1746 $self->{PERL_INC} = $inc;
1747 $self->{UNINSTALLED_PERL} = 1;
1749 ... Detected uninstalled Perl. Trying to continue.
1755 unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1757 Error: Unable to locate installed Perl libraries or Perl source code.
1759 It is recommended that you install perl in a standard location before
1760 building extensions. Some precompiled versions of perl do not contain
1761 these header files, so you cannot build extensions. In such a case,
1762 please build and install your perl from a fresh perl distribution. It
1763 usually solves this kind of problem.
1765 \(You get this message, because MakeMaker could not find "$perl_h"\)
1768 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1769 # if $Verbose && $self->needs_linking();
1773 # We get SITELIBEXP and SITEARCHEXP directly via
1774 # Get_from_Config. When we are running standard modules, these
1775 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1776 # set it to "site". I prefer that INSTALLDIRS be set from outside
1778 $self->{INSTALLDIRS} ||= "site";
1780 # INST_LIB typically pre-set if building an extension after
1781 # perl has been built and installed. Setting INST_LIB allows
1782 # you to build directly into, say $Config::Config{privlibexp}.
1783 unless ($self->{INST_LIB}){
1786 ##### XXXXX We have to change this nonsense
1788 if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1789 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1791 $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1794 $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1795 $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1797 # We need to set up INST_LIBDIR before init_libscan() for VMS
1798 my @parentdir = split(/::/, $self->{PARENT_NAME});
1799 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1800 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1801 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1802 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1804 # INST_EXE is deprecated, should go away March '97
1805 $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1806 $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1808 # The user who requests an installation directory explicitly
1809 # should not have to tell us a architecture installation directory
1810 # as well. We look if a directory exists that is named after the
1811 # architecture. If not we take it as a sign that it should be the
1812 # same as the requested installation directory. Otherwise we take
1814 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1816 for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1817 my $lib = "install$libpair->{l}";
1819 my $Arch = uc "install$libpair->{a}";
1820 if( $self->{$Lib} && ! $self->{$Arch} ){
1821 my($ilib) = $Config{$lib};
1822 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1824 $self->prefixify($Arch,$ilib,$self->{$Lib});
1826 unless (-d $self->{$Arch}) {
1827 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1828 $self->{$Arch} = $self->{$Lib};
1830 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1834 # we have to look at the relation between $Config{prefix} and the
1835 # requested values. We're going to set the $Config{prefix} part of
1836 # all the installation path variables to literally $(PREFIX), so
1837 # the user can still say make PREFIX=foo
1838 my($configure_prefix) = $Config{'prefix'};
1839 $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1840 $self->{PREFIX} ||= $configure_prefix;
1843 my($install_variable,$search_prefix,$replace_prefix);
1845 # If the prefix contains perl, Configure shapes the tree as follows:
1846 # perlprefix/lib/ INSTALLPRIVLIB
1847 # perlprefix/lib/pod/
1848 # perlprefix/lib/site_perl/ INSTALLSITELIB
1849 # perlprefix/bin/ INSTALLBIN
1850 # perlprefix/man/ INSTALLMAN1DIR
1852 # prefix/lib/perl5/ INSTALLPRIVLIB
1853 # prefix/lib/perl5/pod/
1854 # prefix/lib/perl5/site_perl/ INSTALLSITELIB
1855 # prefix/bin/ INSTALLBIN
1856 # prefix/lib/perl5/man/ INSTALLMAN1DIR
1858 # The above results in various kinds of breakage on various
1859 # platforms, so we cope with it as follows: if prefix/lib/perl5
1860 # or prefix/lib/perl5/man exist, we'll replace those instead
1861 # of /prefix/{lib,man}
1863 $replace_prefix = qq[\$\(PREFIX\)];
1864 for $install_variable (qw/
1868 $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1870 my $funkylibdir = $self->catdir($configure_prefix,"lib","perl5");
1871 $funkylibdir = '' unless -d $funkylibdir;
1872 $search_prefix = $funkylibdir || $self->catdir($configure_prefix,"lib");
1874 $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1875 $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1876 $self->catdir($self->{LIB},$Config{'archname'});
1879 if (-d $self->catdir($self->{PREFIX},"lib","perl5")) {
1880 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib", "perl5");
1883 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib");
1885 for $install_variable (qw/
1892 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1895 my $funkymandir = $self->catdir($configure_prefix,"lib","perl5","man");
1896 $funkymandir = '' unless -d $funkymandir;
1897 $search_prefix = $funkymandir || $self->catdir($configure_prefix,"man");
1898 if (-d $self->catdir($self->{PREFIX},"lib","perl5", "man")) {
1899 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib", "perl5", "man");
1902 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"man");
1904 for $install_variable (qw/
1909 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1912 # Now we head at the manpages. Maybe they DO NOT want manpages
1914 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1915 unless defined $self->{INSTALLMAN1DIR};
1916 unless (defined $self->{INST_MAN1DIR}){
1917 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1918 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1920 $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1923 $self->{MAN1EXT} ||= $Config::Config{man1ext};
1925 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1926 unless defined $self->{INSTALLMAN3DIR};
1927 unless (defined $self->{INST_MAN3DIR}){
1928 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1929 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1931 $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1934 $self->{MAN3EXT} ||= $Config::Config{man3ext};
1936 $self->{INSTALLHTMLPRIVLIBDIR} = $Config::Config{installhtmlprivlibdir}
1937 unless defined $self->{INSTALLHTMLPRIVLIBDIR};
1938 $self->{INSTALLHTMLSITELIBDIR} = $Config::Config{installhtmlsitelibdir}
1939 unless defined $self->{INSTALLHTMLSITELIBDIR};
1941 unless (defined $self->{INST_HTMLLIBDIR}){
1942 if ($self->{INSTALLHTMLSITELIBDIR} =~ /^(none|\s*)$/){
1943 $self->{INST_HTMLLIBDIR} = $self->{INSTALLHTMLSITELIBDIR};
1945 $self->{INST_HTMLLIBDIR} = $self->catdir($self->curdir,'blib','html','lib');
1949 $self->{INSTALLHTMLSCRIPTDIR} = $Config::Config{installhtmlscriptdir}
1950 unless defined $self->{INSTALLHTMLSCRIPTDIR};
1951 unless (defined $self->{INST_HTMLSCRIPTDIR}){
1952 if ($self->{INSTALLHTMLSCRIPTDIR} =~ /^(none|\s*)$/){
1953 $self->{INST_HTMLSCRIPTDIR} = $self->{INSTALLHTMLSCRIPTDIR};
1955 $self->{INST_HTMLSCRIPTDIR} = $self->catdir($self->curdir,'blib','html','bin');
1958 $self->{HTMLEXT} ||= $Config::Config{htmlext} || 'html';
1961 # Get some stuff out of %Config if we haven't yet done so
1962 print STDOUT "CONFIG must be an array ref\n"
1963 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1964 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1965 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1966 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1968 foreach $m (@{$self->{CONFIG}}){
1969 next if $once_only{$m};
1970 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1971 unless exists $Config::Config{$m};
1972 $self->{uc $m} ||= $Config::Config{$m};
1976 # This is too dangerous:
1977 # if ($^O eq "next") {
1978 # $self->{AR} = "libtool";
1979 # $self->{AR_STATIC_ARGS} = "-o";
1981 # But I leave it as a placeholder
1983 $self->{AR_STATIC_ARGS} ||= "cr";
1985 # These should never be needed
1986 $self->{LD} ||= 'ld';
1987 $self->{OBJ_EXT} ||= '.o';
1988 $self->{LIB_EXT} ||= '.a';
1990 $self->{MAP_TARGET} ||= "perl";
1992 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1994 # make a simple check if we find Exporter
1995 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1996 (Exporter.pm not found)"
1997 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1998 $self->{NAME} eq "ExtUtils::MakeMaker";
2000 # Determine VERSION and VERSION_FROM
2001 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
2002 if ($self->{VERSION_FROM}){
2003 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
2004 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
2008 if ($self->{VERSION}) {
2009 $self->{VERSION} =~ s/^\s+//;
2010 $self->{VERSION} =~ s/\s+$//;
2013 $self->{VERSION} ||= "0.10";
2014 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
2017 # Graham Barr and Paul Marquess had some ideas how to ensure
2018 # version compatibility between the *.pm file and the
2019 # corresponding *.xs file. The bottomline was, that we need an
2020 # XS_VERSION macro that defaults to VERSION:
2021 $self->{XS_VERSION} ||= $self->{VERSION};
2023 # --- Initialize Perl Binary Locations
2025 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
2026 # will be working versions of perl 5. miniperl has priority over perl
2027 # for PERL to ensure that $(PERL) is usable while building ./ext/*
2028 my ($component,@defpath);
2029 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
2030 push @defpath, $component if defined $component;
2033 $self->find_perl(5.0, [ $self->canonpath($^X), 'miniperl',
2034 'perl','perl5',"perl$Config{version}" ],
2035 \@defpath, $Verbose );
2036 # don't check if perl is executable, maybe they have decided to
2037 # supply switches with perl
2039 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2040 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
2041 unless ($self->{FULLPERL});
2046 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
2047 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
2048 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
2052 sub init_others { # --- Initialize Other Attributes
2055 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
2056 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
2057 # undefined. In any case we turn it into an anon array:
2059 # May check $Config{libs} too, thus not empty.
2060 $self->{LIBS}=[''] unless $self->{LIBS};
2062 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
2063 $self->{LD_RUN_PATH} = "";
2065 foreach $libs ( @{$self->{LIBS}} ){
2066 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
2067 my(@libs) = $self->extliblist($libs);
2068 if ($libs[0] or $libs[1] or $libs[2]){
2069 # LD_RUN_PATH now computed by ExtUtils::Liblist
2070 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
2075 if ( $self->{OBJECT} ) {
2076 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
2078 # init_dirscan should have found out, if we have C files
2079 $self->{OBJECT} = "";
2080 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
2082 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
2083 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
2084 $self->{PERLMAINCC} ||= '$(CC)';
2085 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
2087 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
2088 # the 'dynamic' section of MM. We don't have this problem with
2089 # 'static', since we either must use it (%Config says we can't
2090 # use dynamic loading) or the caller asked for it explicitly.
2091 if (!$self->{LINKTYPE}) {
2092 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
2094 : ($Config::Config{usedl} ? 'dynamic' : 'static');
2097 # These get overridden for VMS and maybe some other systems
2098 $self->{NOOP} ||= '$(SHELL) -c true';
2099 $self->{FIRST_MAKEFILE} ||= "Makefile";
2100 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
2101 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
2102 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
2103 $self->{RM_F} ||= "rm -f";
2104 $self->{RM_RF} ||= "rm -rf";
2105 $self->{TOUCH} ||= "touch";
2106 $self->{TEST_F} ||= "test -f";
2107 $self->{CP} ||= "cp";
2108 $self->{MV} ||= "mv";
2109 $self->{CHMOD} ||= "chmod";
2110 $self->{UMASK_NULL} ||= "umask 0";
2111 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
2116 Defines the install target.
2121 my($self, %attribs) = @_;
2125 install :: all pure_install doc_install
2127 install_perl :: all pure_perl_install doc_perl_install
2129 install_site :: all pure_site_install doc_site_install
2131 install_ :: install_site
2132 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2134 pure_install :: pure_$(INSTALLDIRS)_install
2136 doc_install :: doc_$(INSTALLDIRS)_install
2137 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2139 pure__install : pure_site_install
2140 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2142 doc__install : doc_site_install
2143 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2145 pure_perl_install ::
2146 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2147 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2148 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2149 $(INST_LIB) $(INSTALLPRIVLIB) \
2150 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2151 $(INST_BIN) $(INSTALLBIN) \
2152 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2153 $(INST_HTMLLIBDIR) $(INSTALLHTMLPRIVLIBDIR) \
2154 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2155 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2156 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2157 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2158 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2161 pure_site_install ::
2162 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2163 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2164 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2165 $(INST_LIB) $(INSTALLSITELIB) \
2166 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2167 $(INST_BIN) $(INSTALLBIN) \
2168 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2169 $(INST_HTMLLIBDIR) $(INSTALLHTMLSITELIBDIR) \
2170 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2171 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2172 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2173 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2174 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2177 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2178 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2179 "Module" "$(NAME)" \
2180 "installed into" "$(INSTALLPRIVLIB)" \
2181 LINKTYPE "$(LINKTYPE)" \
2182 VERSION "$(VERSION)" \
2183 EXE_FILES "$(EXE_FILES)" \
2184 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2187 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2188 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2189 "Module" "$(NAME)" \
2190 "installed into" "$(INSTALLSITELIB)" \
2191 LINKTYPE "$(LINKTYPE)" \
2192 VERSION "$(VERSION)" \
2193 EXE_FILES "$(EXE_FILES)" \
2194 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2199 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2201 uninstall_from_perldirs ::
2203 q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2205 uninstall_from_sitedirs ::
2207 q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2213 =item installbin (o)
2215 Defines targets to make and to install EXE_FILES.
2221 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2222 return "" unless @{$self->{EXE_FILES}};
2223 my(@m, $from, $to, %fromto, @to);
2224 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2225 for $from (@{$self->{EXE_FILES}}) {
2226 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2227 local($_) = $path; # for backwards compatibility
2228 $to = $self->libscan($path);
2229 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2232 @to = values %fromto;
2234 EXE_FILES = @{$self->{EXE_FILES}}
2237 ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2238 -e "system qq[pl2bat.bat ].shift"
2239 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2240 -e "MY->fixin(shift)"
2243 $self->{NOECHO}\$(NOOP)
2249 while (($from,$to) = each %fromto) {
2250 last unless defined $from;
2251 my $todir = dirname($to);
2253 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2254 $self->{NOECHO}$self->{RM_F} $to
2255 $self->{CP} $from $to
2257 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2265 Takes a path to a file that is found by init_dirscan and returns false
2266 if we don't want to include this file in the library. Mainly used to
2267 exclude RCS, CVS, and SCCS directories from installation.
2274 my($self,$path) = @_;
2275 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2281 Defines the linkext target which in turn defines the LINKTYPE.
2286 my($self, %attribs) = @_;
2287 # LINKTYPE => static or dynamic or ''
2288 my($linktype) = defined $attribs{LINKTYPE} ?
2289 $attribs{LINKTYPE} : '$(LINKTYPE)';
2291 linkext :: $linktype
2292 $self->{NOECHO}\$(NOOP)
2298 Takes as arguments a directory name and a regular expression. Returns
2299 all entries in the directory that match the regular expression.
2305 my($dir, $regex) = @_;
2307 my $dh = new DirHandle;
2308 $dh->open($dir || ".") or return ();
2311 @ls = grep(/$regex/, @ls) if $regex;
2317 Simple subroutine to insert the macros defined by the macro attribute
2323 my($self,%attribs) = @_;
2325 while (($key,$val) = each %attribs){
2326 last unless defined $key;
2327 push @m, "$key = $val\n";
2334 Called by staticmake. Defines how to write the Makefile to produce a
2337 By default the Makefile produced includes all the static extensions in
2338 the perl library. (Purified versions of library files, e.g.,
2339 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2344 my($self, %attribs) = @_;
2345 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2346 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2349 # --- MakeMaker makeaperl section ---
2350 MAP_TARGET = $target
2351 FULLPERL = $self->{FULLPERL}
2353 return join '', @m if $self->{PARENT};
2355 my($dir) = join ":", @{$self->{DIR}};
2357 unless ($self->{MAKEAPERL}) {
2359 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2360 $(MAKE) -f $(MAKE_APERL_FILE) $@
2362 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2363 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2364 }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2365 Makefile.PL DIR=}, $dir, q{ \
2366 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2367 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2373 push @m, " \\\n\t\t$_";
2375 # push @m, map( " \\\n\t\t$_", @ARGV );
2383 my($cccmd, $linkcmd, $lperl);
2386 $cccmd = $self->const_cccmd($libperl);
2387 $cccmd =~ s/^CCCMD\s*=\s*//;
2388 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2389 $cccmd .= " $Config::Config{cccdlflags}"
2390 if ($Config::Config{useshrplib} eq 'true');
2391 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2393 # The front matter of the linkcommand...
2394 $linkcmd = join ' ', "\$(CC)",
2395 grep($_, @Config{qw(ldflags ccdlflags)});
2396 $linkcmd =~ s/\s+/ /g;
2397 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2399 # Which *.a files could we make use of...
2402 File::Find::find(sub {
2403 return unless m/\Q$self->{LIB_EXT}\E$/;
2404 return if m/^libperl/;
2405 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2406 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2408 if( exists $self->{INCLUDE_EXT} ){
2413 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2417 # Throw away anything not explicitly marked for inclusion.
2418 # DynaLoader is implied.
2419 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2425 return unless $found;
2427 elsif( exists $self->{EXCLUDE_EXT} ){
2431 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2435 # Throw away anything explicitly marked for exclusion
2436 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2437 return if( $xx eq $excl );
2441 # don't include the installed version of this extension. I
2442 # leave this line here, although it is not necessary anymore:
2443 # I patched minimod.PL instead, so that Miniperl.pm won't
2444 # enclude duplicates
2446 # Once the patch to minimod.PL is in the distribution, I can
2448 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2450 $static{cwd() . "/" . $_}++;
2451 }, grep( -d $_, @{$searchdirs || []}) );
2453 # We trust that what has been handed in as argument, will be buildable
2454 $static = [] unless $static;
2455 @static{@{$static}} = (1) x @{$static};
2457 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2458 for (sort keys %static) {
2459 next unless /\Q$self->{LIB_EXT}\E\z/;
2460 $_ = dirname($_) . "/extralibs.ld";
2464 grep(s/^/-I/, @{$perlinc || []});
2466 $target = "perl" unless $target;
2467 $tmp = "." unless $tmp;
2469 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2470 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2471 # extralibs.all are computed correctly
2473 MAP_LINKCMD = $linkcmd
2474 MAP_PERLINC = @{$perlinc || []}
2476 join(" \\\n\t", reverse sort keys %static), "
2478 MAP_PRELIBS = $Config::Config{perllibs} $Config::Config{cryptlib}
2481 if (defined $libperl) {
2482 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2484 unless ($libperl && -f $lperl) { # Ilya's code...
2485 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2486 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2487 $libperl ||= "libperl$self->{LIB_EXT}";
2488 $libperl = "$dir/$libperl";
2489 $lperl ||= "libperl$self->{LIB_EXT}";
2490 $lperl = "$dir/$lperl";
2492 if (! -f $libperl and ! -f $lperl) {
2493 # We did not find a static libperl. Maybe there is a shared one?
2494 if ($^O eq 'solaris' or $^O eq 'sunos') {
2495 $lperl = $libperl = "$dir/$Config::Config{libperl}";
2496 # SUNOS ld does not take the full path to a shared library
2497 $libperl = '' if $^O eq 'sunos';
2501 print STDOUT "Warning: $libperl not found
2502 If you're going to build a static perl binary, make sure perl is installed
2503 otherwise ignore this warning\n"
2504 unless (-f $lperl || defined($self->{PERL_SRC}));
2508 MAP_LIBPERL = $libperl
2512 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2513 $self->{NOECHO}$self->{RM_F} \$\@
2514 $self->{NOECHO}\$(TOUCH) \$\@
2518 foreach $catfile (@$extra){
2519 push @m, "\tcat $catfile >> \$\@\n";
2521 # SUNOS ld does not take the full path to a shared library
2522 my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2525 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2526 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) $llibperl `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2527 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2528 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2529 $self->{NOECHO}echo 'To remove the intermediate files say'
2530 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2532 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2534 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2537 $tmp/perlmain.c: $makefilename}, q{
2538 }.$self->{NOECHO}.q{echo Writing $@
2539 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2540 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2543 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2544 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2549 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2550 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2551 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2552 "Perl binary" "$(MAP_TARGET)" \
2553 MAP_STATIC "$(MAP_STATIC)" \
2554 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2555 MAP_LIBPERL "$(MAP_LIBPERL)" \
2556 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2561 inst_perl: pure_inst_perl doc_inst_perl
2563 pure_inst_perl: $(MAP_TARGET)
2564 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2569 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2577 Defines how to rewrite the Makefile.
2584 # We do not know what target was originally specified so we
2585 # must force a manual rerun to be sure. But as it should only
2586 # happen very rarely it is not a significant problem.
2588 $(OBJECT) : $(FIRST_MAKEFILE)
2589 ' if $self->{OBJECT};
2592 # We take a very conservative approach here, but it\'s worth it.
2593 # We move Makefile to Makefile.old here to avoid gnu make looping.
2594 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2595 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2596 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2597 -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2598 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2599 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2600 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2601 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2602 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2605 # To change behavior to :: would be nice, but would break Tk b9.02
2606 # so you find such a warning below the dist target.
2607 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2608 # }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2614 =item manifypods (o)
2616 Defines targets and routines to translate the pods into manpages and
2617 put them into the INST_* directories.
2622 my($self, %attribs) = @_;
2623 return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2624 %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2627 if (defined $self->{PERL_SRC}) {
2628 $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2630 $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2632 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2633 # Maybe a build by uninstalled Perl?
2634 $pod2man_exe = $self->catfile($self->{PERL_INC}, "pod", "pod2man");
2636 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2637 # No pod2man but some MAN3PODS to be installed
2640 Warning: I could not locate your pod2man program. Please make sure,
2641 your pod2man program is in your PATH before you execute 'make'
2644 $pod2man_exe = "-S pod2man";
2648 qq[POD2MAN_EXE = $pod2man_exe\n],
2649 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2650 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2651 $self->{MAKEFILE}, q[";' \\
2652 -e 'print "Manifying $$m{$$_}\n";' \\
2653 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2654 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2656 push @m, "\nmanifypods : pure_all ";
2657 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2660 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2661 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2662 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2669 Returns true, if the argument is likely to be a command.
2674 my($self,$file) = @_;
2675 return $file if -x $file && ! -d $file;
2679 =item maybe_command_in_dirs
2681 method under development. Not yet used. Ask Ilya :-)
2685 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2686 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2687 my($self, $names, $dirs, $trace, $ver) = @_;
2689 foreach $dir (@$dirs){
2690 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2691 foreach $name (@$names){
2693 if ($self->file_name_is_absolute($name)) { # /foo/bar
2695 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2696 $abs = $self->catfile($dir, $name);
2698 $abs = $self->catfile($self->curdir, $name);
2700 print "Checking $abs for $name\n" if ($trace >= 2);
2701 next unless $tryabs = $self->maybe_command($abs);
2702 print "Substituting $tryabs instead of $abs\n"
2703 if ($trace >= 2 and $tryabs ne $abs);
2706 print "Executing $abs\n" if ($trace >= 2);
2707 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2708 print "Using PERL=$abs\n" if $trace;
2711 } else { # Do not look for perl
2718 =item needs_linking (o)
2720 Does this module need linking? Looks into subdirectory objects (see
2721 also has_link_code())
2728 $caller = (caller(0))[3];
2729 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2730 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2731 if ($self->has_link_code or $self->{MAKEAPERL}){
2732 $self->{NEEDS_LINKING} = 1;
2735 foreach $child (keys %{$self->{CHILDREN}}) {
2736 if ($self->{CHILDREN}->{$child}->needs_linking) {
2737 $self->{NEEDS_LINKING} = 1;
2741 return $self->{NEEDS_LINKING} = 0;
2746 misnamed method (will have to be changed). The MM_Unix method just
2747 returns the argument without further processing.
2749 On VMS used to insure that colons marking targets are preceded by
2750 space - most Unix Makes don't need this, but it's necessary under VMS
2751 to distinguish the target delimiter from a colon appearing as part of
2757 my($self,$text) = @_;
2763 parse a file and return what you think is $VERSION in this file set to.
2764 It will return the string "undef" if it can't figure out what $VERSION
2770 my($self,$parsefile) = @_;
2774 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2777 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2780 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2781 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2783 package ExtUtils::MakeMaker::_version;
2792 $result = eval($eval);
2793 warn "Could not eval '$eval' in $parsefile: $@" if $@;
2794 $result = "undef" unless defined $result;
2801 =item parse_abstract
2803 parse a file and return what you think is the ABSTRACT
2807 sub parse_abstract {
2808 my($self,$parsefile) = @_;
2812 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2814 my $package = $self->{DISTNAME};
2815 $package =~ s/-/::/g;
2817 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2820 next unless /^($package\s-\s)(.*)/;
2830 Defines the string that is passed to recursive make calls in
2840 my($sep) = $Is_VMS ? ',' : '';
2843 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2844 push @pasthru, "$key=\"\$($key)\"";
2847 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2853 Takes no argument, returns the environment variable PATH as an array.
2859 my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2860 my $path = $ENV{PATH};
2861 $path =~ s:\\:/:g if $Is_OS2;
2862 my @path = split $path_sep, $path;
2863 foreach(@path) { $_ = '.' if $_ eq '' }
2869 Takes one argument, a file name, and returns the file name, if the
2870 argument is likely to be a perl script. On MM_Unix this is true for
2871 any ordinary, readable file.
2876 my($self,$file) = @_;
2877 return $file if -r $file && -f _;
2881 =item perldepend (o)
2883 Defines the dependency from all *.h files that come with the perl
2892 # Check for unpropogated config.sh changes. Should never happen.
2893 # We do NOT just update config.h because that is not sufficient.
2894 # An out of date config.h is not fatal but complains loudly!
2895 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2896 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2898 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2899 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2900 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2901 } if $self->{PERL_SRC};
2903 return join "", @m unless $self->needs_linking;
2907 $(PERL_INC)/EXTERN.h \
2908 $(PERL_INC)/INTERN.h \
2909 $(PERL_INC)/XSUB.h \
2911 $(PERL_INC)/cc_runtime.h \
2912 $(PERL_INC)/config.h \
2915 $(PERL_INC)/dosish.h \
2916 $(PERL_INC)/embed.h \
2917 $(PERL_INC)/embedvar.h \
2918 $(PERL_INC)/fakethr.h \
2919 $(PERL_INC)/form.h \
2921 $(PERL_INC)/handy.h \
2923 $(PERL_INC)/intrpvar.h \
2924 $(PERL_INC)/iperlsys.h \
2925 $(PERL_INC)/keywords.h \
2927 $(PERL_INC)/nostdio.h \
2928 $(PERL_INC)/objXSUB.h \
2930 $(PERL_INC)/opcode.h \
2931 $(PERL_INC)/opnames.h \
2932 $(PERL_INC)/patchlevel.h \
2933 $(PERL_INC)/perl.h \
2934 $(PERL_INC)/perlapi.h \
2935 $(PERL_INC)/perlio.h \
2936 $(PERL_INC)/perlsdio.h \
2937 $(PERL_INC)/perlsfio.h \
2938 $(PERL_INC)/perlvars.h \
2939 $(PERL_INC)/perly.h \
2941 $(PERL_INC)/pp_proto.h \
2942 $(PERL_INC)/proto.h \
2943 $(PERL_INC)/regcomp.h \
2944 $(PERL_INC)/regexp.h \
2945 $(PERL_INC)/regnodes.h \
2946 $(PERL_INC)/scope.h \
2948 $(PERL_INC)/thrdvar.h \
2949 $(PERL_INC)/thread.h \
2950 $(PERL_INC)/unixish.h \
2951 $(PERL_INC)/utf8.h \
2952 $(PERL_INC)/util.h \
2953 $(PERL_INC)/warnings.h
2955 $(OBJECT) : $(PERL_HDRS)
2956 } if $self->{OBJECT};
2958 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2965 Defines target that creates a PPD (Perl Package Description) file
2966 for a binary distribution.
2973 if ($self->{ABSTRACT_FROM}){
2974 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2975 Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2977 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2978 push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2980 push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2981 push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2982 my $abstract = $self->{ABSTRACT};
2983 $abstract =~ s/\n/\\n/sg;
2984 $abstract =~ s/</</g;
2985 $abstract =~ s/>/>/g;
2986 push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2987 my ($author) = $self->{AUTHOR};
2988 $author =~ s/</</g;
2989 $author =~ s/>/>/g;
2990 $author =~ s/@/\\@/g;
2991 push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2992 push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2994 foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2995 my $pre_req = $prereq;
2996 $pre_req =~ s/::/-/g;
2997 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), (0) x 4) [0 .. 3];
2998 push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" VERSION=\\\"$dep_ver\\\" />\\n}");
3000 push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
3001 push(@m, ". qq{\\t\\t<ARCHITECTURE NAME=\\\"$Config{'archname'}\\\" />\\n}");
3002 my ($bin_location) = $self->{BINARY_LOCATION};
3003 $bin_location =~ s/\\/\\\\/g;
3004 if ($self->{PPM_INSTALL_SCRIPT}) {
3005 if ($self->{PPM_INSTALL_EXEC}) {
3006 push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3009 push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3012 push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
3013 push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
3014 push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
3021 Returns the attribute C<PERM_RW> or the string C<644>.
3022 Used as the string that is passed
3023 to the C<chmod> command to set the permissions for read/writeable files.
3024 MakeMaker chooses C<644> because it has turned out in the past that
3025 relying on the umask provokes hard-to-track bug reports.
3026 When the return value is used by the perl function C<chmod>, it is
3027 interpreted as an octal value.
3032 shift->{PERM_RW} || "644";
3037 Returns the attribute C<PERM_RWX> or the string C<755>,
3038 i.e. the string that is passed
3039 to the C<chmod> command to set the permissions for executable files.
3045 shift->{PERM_RWX} || "755";
3050 Defines target that copies all files in the hash PM to their
3051 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3057 my($autodir) = $self->catdir('$(INST_LIB)','auto');
3059 pm_to_blib: $(TO_INST_PM)
3060 }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
3061 "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
3062 -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{','$(PM_FILTER)')"
3063 }.$self->{NOECHO}.q{$(TOUCH) $@
3067 =item post_constants (o)
3069 Returns an empty string per default. Dedicated to overrides from
3070 within Makefile.PL after all constants have been defined.
3079 =item post_initialize (o)
3081 Returns an empty string per default. Used in Makefile.PLs to add some
3082 chunk of text to the Makefile after the object is initialized.
3086 sub post_initialize {
3093 Returns an empty string. Can be used in Makefile.PLs to write some
3094 text to the Makefile at the end.
3105 Check a path variable in $self from %Config, if it contains a prefix,
3106 and replace it with another one.
3108 Takes as arguments an attribute name, a search prefix and a
3109 replacement prefix. Changes the attribute in the object.
3114 my($self,$var,$sprefix,$rprefix) = @_;
3115 $self->{uc $var} ||= $Config{lc $var};
3116 $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
3117 $self->{uc $var} =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s;
3122 Defines targets to run *.PL files.
3128 return "" unless $self->{PL_FILES};
3130 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3131 my $list = ref($self->{PL_FILES}->{$plfile})
3132 ? $self->{PL_FILES}->{$plfile}
3133 : [$self->{PL_FILES}->{$plfile}];
3135 foreach $target (@$list) {
3138 $self->{NOECHO}\$(NOOP)
3141 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile $target
3150 Defines the realclean target.
3155 my($self, %attribs) = @_;
3158 # Delete temporary files (via clean) and also delete installed files
3159 realclean purge :: clean
3161 # realclean subdirectories first (already cleaned)
3162 my $sub = ($Is_Win32 && Win32::IsWin95()) ?
3163 "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3164 "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3165 foreach(@{$self->{DIR}}){
3166 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3167 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3169 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3170 if( $self->has_link_code ){
3171 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3172 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
3174 # Issue a several little RM_F commands rather than risk creating a
3175 # very long command line (useful for extensions such as Encode
3176 # that have many files).
3177 if (keys %{$self->{PM}}) {
3179 foreach (values %{$self->{PM}}) {
3180 if (length($line) + length($_) > 80) {
3181 push @m, "\t$self->{RM_F} $line\n";
3188 push @m, "\t$self->{RM_F} $line\n" if $line;
3190 my(@otherfiles) = ($self->{MAKEFILE},
3191 "$self->{MAKEFILE}.old"); # Makefiles last
3192 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3193 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
3194 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
3198 =item replace_manpage_separator
3200 Takes the name of a package, which may be a nested package, in the
3201 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3205 sub replace_manpage_separator {
3206 my($self,$man) = @_;
3207 if ($^O eq 'uwin') {
3219 Defines the static target.
3224 # --- Static Loading Sections ---
3228 ## $(INST_PM) has been moved to the all: target.
3229 ## It remains here for awhile to allow for old usage: "make static"
3230 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3231 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3232 '.$self->{NOECHO}.'$(NOOP)
3236 =item static_lib (o)
3238 Defines how to produce the *.a (or equivalent) files.
3244 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3245 # return '' unless $self->needs_linking(); #might be because of a subdir
3247 return '' unless $self->has_link_code;
3251 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3254 # If this extension has it's own library (eg SDBM_File)
3255 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3256 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3259 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3260 # Prefer the absolute pathed ar if available so that PATH
3261 # doesn't confuse us. Perl itself is built with the full_ar.
3267 "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3269 q{ $(CHMOD) $(PERM_RWX) $@
3270 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3272 # Old mechanism - still available:
3274 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3275 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
3278 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3282 =item staticmake (o)
3289 my($self, %attribs) = @_;
3292 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3294 # And as it's not yet built, we add the current extension
3295 # but only if it has some C code (or XS code, which implies C code)
3296 if (@{$self->{C}}) {
3297 @static = $self->catfile($self->{INST_ARCHLIB},
3300 "$self->{BASEEXT}$self->{LIB_EXT}"
3304 # Either we determine now, which libraries we will produce in the
3305 # subdirectories or we do it at runtime of the make.
3307 # We could ask all subdir objects, but I cannot imagine, why it
3308 # would be necessary.
3310 # Instead we determine all libraries for the new perl at
3312 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3314 $self->makeaperl(MAKE => $self->{MAKEFILE},
3315 DIRS => \@searchdirs,
3318 TARGET => $self->{MAP_TARGET},
3320 LIBPERL => $self->{LIBPERL_A}
3326 Helper subroutine for subdirs
3331 my($self, $subdir) = @_;
3333 if ($Is_Win32 && Win32::IsWin95()) {
3334 if ($Config{'make'} =~ /dmake/i) {
3340 \$(MAKE) all \$(PASTHRU)
3344 } elsif ($Config{'make'} =~ /nmake/i) {
3349 \$(MAKE) all \$(PASTHRU)
3357 $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3365 Defines targets to process subdirectories.
3370 # --- Sub-directory Sections ---
3373 # This method provides a mechanism to automatically deal with
3374 # subdirectories containing further Makefile.PL scripts.
3375 # It calls the subdir_x() method for each subdirectory.
3376 foreach $dir (@{$self->{DIR}}){
3377 push(@m, $self->subdir_x($dir));
3378 #### print "Including $dir subdirectory\n";
3382 # The default clean, realclean and test targets in this Makefile
3383 # have automatically been given entries for each subdir.
3387 push(@m, "\n# none")
3394 Defines the test targets.
3399 # --- Test and Installation Sections ---
3401 my($self, %attribs) = @_;
3402 my $tests = $attribs{TESTS};
3403 if (!$tests && -d 't') {
3404 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3406 # note: 'test.pl' name is also hardcoded in init_dirscan()
3410 TEST_TYPE=test_\$(LINKTYPE)
3415 testdb :: testdb_\$(LINKTYPE)
3417 test :: \$(TEST_TYPE)
3419 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3421 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3422 unless $tests or -f "test.pl" or @{$self->{DIR}};
3425 push(@m, "test_dynamic :: pure_all\n");
3426 push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3427 push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3430 push(@m, "testdb_dynamic :: pure_all\n");
3431 push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3434 # Occasionally we may face this degenerate target:
3435 push @m, "test_ : test_dynamic\n\n";
3437 if ($self->needs_linking()) {
3438 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3439 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3440 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3442 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3443 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3446 push @m, "test_static :: test_dynamic\n";
3447 push @m, "testdb_static :: testdb_dynamic\n";
3452 =item test_via_harness (o)
3454 Helper method to write the test targets
3458 sub test_via_harness {
3459 my($self, $perl, $tests) = @_;
3460 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3461 "\t$perl".q! -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
3464 =item test_via_script (o)
3466 Other helper method for test.
3470 sub test_via_script {
3471 my($self, $perl, $script) = @_;
3472 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3473 qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3477 =item tool_autosplit (o)
3479 Defines a simple perl call that runs autosplit. May be deprecated by
3484 sub tool_autosplit {
3485 # --- Tool Sections ---
3487 my($self, %attribs) = @_;
3489 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3491 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3492 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3496 =item tools_other (o)
3498 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3499 the Makefile. Also defines the perl programs MKPATH,
3500 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3507 my $bin_sh = $Config{sh} || '/bin/sh';
3512 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3513 push @m, "$_ = $self->{$_}\n";
3517 # The following is a portable way to say mkdir -p
3518 # To see which directories are created, change the if 0 to if 1
3519 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3521 # This helps us to minimize the effect of the .exists files A yet
3522 # better solution would be to have a stable file in the perl
3523 # distribution with a timestamp of zero. But this solution doesn't
3524 # need any changes to the core distribution and works with older perls
3525 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3529 return join "", @m if $self->{PARENT};
3532 # Here we warn users that an old packlist file was found somewhere,
3533 # and that they should call some uninstall routine
3534 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3535 -e 'print "WARNING: I have found an old package in\n";' \\
3536 -e 'print "\t$$ARGV[0].\n";' \\
3537 -e 'print "Please make sure the two installations are not conflicting\n";'
3542 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3543 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3545 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3546 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3547 -e 'print "=over 4";' \
3548 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3551 UNINSTALL = $(PERL) -MExtUtils::Install \
3552 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3553 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3554 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3560 =item tool_xsubpp (o)
3562 Determines typemaps, xsubpp version, prototype behaviour.
3568 return "" unless $self->needs_linking;
3569 my($xsdir) = $self->catdir($self->{PERL_LIB},"ExtUtils");
3570 my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3571 if( $self->{TYPEMAPS} ){
3573 foreach $typemap (@{$self->{TYPEMAPS}}){
3574 if( ! -f $typemap ){
3575 warn "Typemap $typemap not found.\n";
3578 push(@tmdeps, $typemap);
3582 push(@tmdeps, "typemap") if -f "typemap";
3583 my(@tmargs) = map("-typemap $_", @tmdeps);
3584 if( exists $self->{XSOPT} ){
3585 unshift( @tmargs, $self->{XSOPT} );
3589 my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3591 # What are the correct thresholds for version 1 && 2 Paul?
3592 if ( $xsubpp_version > 1.923 ){
3593 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3595 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3596 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3597 Your version of xsubpp is $xsubpp_version and cannot handle this.
3598 Please upgrade to a more recent version of xsubpp.
3601 $self->{XSPROTOARG} = "";
3605 my $xsubpp = "xsubpp";
3609 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3610 XSPROTOARG = $self->{XSPROTOARG}
3611 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3612 XSUBPPARGS = @tmargs
3618 my($self,$xsubpp) = @_;
3619 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3623 # try to figure out the version number of the xsubpp on the system
3625 # first try the -v flag, introduced in 1.921 & 2.000a2
3627 return "" unless $self->needs_linking;
3629 my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3630 print "Running $command\n" if $Verbose >= 2;
3631 $version = `$command` ;
3632 warn "Running '$command' exits with status " . ($?>>8) if $?;
3635 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3637 # nope, then try something else
3639 my $counter = '000';
3640 my ($file) = 'temp' ;
3641 $counter++ while -e "$file$counter"; # don't overwrite anything
3644 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3646 MODULE = fred PACKAGE = fred
3655 $command = "$self->{PERL} $xsubpp $file 2>&1";
3656 print "Running $command\n" if $Verbose >= 2;
3657 my $text = `$command` ;
3658 warn "Running '$command' exits with status " . ($?>>8) if $?;
3661 # gets 1.2 -> 1.92 and 2.000a1
3662 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3664 # it is either 1.0 or 1.1
3665 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3667 # none of the above, so 1.0
3668 return $Xsubpp_Version = "1.0" ;
3671 =item top_targets (o)
3673 Defines the targets all, subdirs, config, and O_FILES
3678 # --- Target Sections ---
3683 #all :: config $(INST_PM) subdirs linkext manifypods
3687 all :: pure_all htmlifypods manifypods
3688 '.$self->{NOECHO}.'$(NOOP)
3690 unless $self->{SKIPHASH}{'all'};
3693 pure_all :: config pm_to_blib subdirs linkext
3694 '.$self->{NOECHO}.'$(NOOP)
3696 subdirs :: $(MYEXTLIB)
3697 '.$self->{NOECHO}.'$(NOOP)
3699 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3700 '.$self->{NOECHO}.'$(NOOP)
3702 config :: $(INST_ARCHAUTODIR)/.exists
3703 '.$self->{NOECHO}.'$(NOOP)
3705 config :: $(INST_AUTODIR)/.exists
3706 '.$self->{NOECHO}.'$(NOOP)
3709 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3711 if (%{$self->{HTMLLIBPODS}}) {
3713 config :: \$(INST_HTMLLIBDIR)/.exists
3714 $self->{NOECHO}\$(NOOP)
3717 push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3720 if (%{$self->{HTMLSCRIPTPODS}}) {
3722 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3723 $self->{NOECHO}\$(NOOP)
3726 push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3729 if (%{$self->{MAN1PODS}}) {
3731 config :: \$(INST_MAN1DIR)/.exists
3732 $self->{NOECHO}\$(NOOP)
3735 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3737 if (%{$self->{MAN3PODS}}) {
3739 config :: \$(INST_MAN3DIR)/.exists
3740 $self->{NOECHO}\$(NOOP)
3743 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3747 $(O_FILES): $(H_FILES)
3748 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3752 perldoc ExtUtils::MakeMaker
3757 }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3758 -MExtUtils::MakeMaker=Version_check \
3759 -e "Version_check('$(MM_VERSION)')"
3767 Obsolete, deprecated method. Not used since Version 5.21.
3772 # --- perllocal.pod section ---
3773 my($self,$what,$name,@attribs)=@_;
3774 my $time = localtime;
3775 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3776 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3777 print "\n\n=back\n\n";
3782 Defines the suffix rules to compile XS files to C.
3788 return '' unless $self->needs_linking();
3791 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3797 Defines the suffix rules to compile XS files to C++.
3803 return '' unless $self->needs_linking();
3806 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3812 Defines suffix rules to go from XS to object files directly. This is
3813 only intended for broken make implementations.
3817 sub xs_o { # many makes are too dumb to use xs_c then c_o
3819 return '' unless $self->needs_linking();
3822 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3823 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3829 This is internal method that returns path to libperl.a equivalent
3830 to be linked to dynamic extensions. UNIX does not have one but OS2
3837 return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3841 =item perl_archive_after
3843 This is an internal method that returns path to a library which
3844 should be put on the linker command line I<after> the external libraries
3845 to be linked to dynamic extensions. This may be needed if the linker
3846 is one-pass, and Perl includes some overrides for C RTL functions,
3851 sub perl_archive_after
3858 This is internal method that returns name of a file that is
3859 passed to linker to define symbols to be exported.
3860 UNIX does not have one but OS2 and Win32 do.
3876 L<ExtUtils::MakeMaker>