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 perl perl$(EXE_EXT)
470 $(BOOTSTRAP) $(BASEEXT).bso
471 $(BASEEXT).def lib$(BASEEXT).def
474 push @m, "\t-$self->{RM_RF} @otherfiles\n";
475 # See realclean and ext/utils/make_ext for usage of Makefile.old
477 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
479 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
483 =item const_cccmd (o)
485 Returns the full compiler call for C programs and stores the
486 definition in CONST_CCCMD.
491 my($self,$libperl)=@_;
492 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
493 return '' unless $self->needs_linking();
494 return $self->{CONST_CCCMD} =
495 q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
496 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
497 $(XS_DEFINE_VERSION)};
500 =item const_config (o)
502 Defines a couple of constants in the Makefile that are imported from
508 # --- Constants Sections ---
512 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
513 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
515 foreach $m (@{$self->{CONFIG}}){
516 # SITE*EXP macros are defined in &constants; avoid duplicates here
517 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
518 push @m, "\U$m\E = ".$self->{uc $m}."\n";
524 =item const_loadlibs (o)
526 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
527 L<ExtUtils::Liblist> for details.
533 return "" unless $self->needs_linking;
536 # $self->{NAME} might depend on some other libraries:
537 # See ExtUtils::Liblist for details
542 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
544 next unless defined $self->{$tmp};
545 push @m, "$tmp = $self->{$tmp}\n";
552 Initializes lots of constants and .SUFFIXES and .PHONY
562 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
563 VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
564 INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
565 INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
566 INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
567 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
568 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
569 PERL_INC PERL FULLPERL FULL_AR
572 next unless defined $self->{$tmp};
573 push @m, "$tmp = $self->{$tmp}\n";
577 VERSION_MACRO = VERSION
578 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
579 XS_VERSION_MACRO = XS_VERSION
580 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
581 PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc
585 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
586 MM_VERSION = $ExtUtils::MakeMaker::VERSION
590 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
591 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
592 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD) !!! Deprecated from MM 5.32 !!!
593 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
594 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
598 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
599 LDFROM LINKTYPE PM_FILTER
601 next unless defined $self->{$tmp};
602 push @m, "$tmp = $self->{$tmp}\n";
606 # Handy lists of source code files:
607 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
608 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
609 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
610 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
611 HTMLLIBPODS = ".join(" \\\n\t", sort keys %{$self->{HTMLLIBPODS}})."
612 HTMLSCRIPTPODS = ".join(" \\\n\t", sort keys %{$self->{HTMLSCRIPTPODS}})."
613 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
614 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
618 INST_HTMLPRIVLIBDIR INSTALLHTMLPRIVLIBDIR
619 INST_HTMLSITELIBDIR INSTALLHTMLSITELIBDIR
620 INST_HTMLSCRIPTDIR INSTALLHTMLSCRIPTDIR
621 INST_HTMLLIBDIR HTMLEXT
622 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT
623 INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
625 next unless defined $self->{$tmp};
626 push @m, "$tmp = $self->{$tmp}\n";
633 my $method = lc($tmp);
634 # warn "self[$self] method[$method]";
635 push @m, "$tmp = ", $self->$method(), "\n";
639 .NO_CONFIG_REC: Makefile
640 } if $ENV{CLEARCASE_ROOT};
642 # why not q{} ? -- emacs
644 # work around a famous dec-osf make(1) feature(?):
647 .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc \$(OBJ_EXT)
649 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
650 # some make implementations will delete the Makefile when we rebuild it. Because
651 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
652 # does so. Our milage may vary.
653 # .PRECIOUS: Makefile # seems to be not necessary anymore
655 .PHONY: all config static dynamic test linkext manifest
657 # Where is the Config information that we are using/depend on
658 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
661 my @parentdir = split(/::/, $self->{PARENT_NAME});
663 # Where to put things:
664 INST_LIBDIR = }. $self->catdir('$(INST_LIB)',@parentdir) .q{
665 INST_ARCHLIBDIR = }. $self->catdir('$(INST_ARCHLIB)',@parentdir) .q{
667 INST_AUTODIR = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
668 INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
671 if ($self->has_link_code()) {
673 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
674 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
675 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
685 $tmp = $self->export_list;
689 $tmp = $self->perl_archive;
693 $tmp = $self->perl_archive_after;
695 PERL_ARCHIVE_AFTER = $tmp
699 #INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
701 #PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
705 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
707 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
715 Same as macro for the depend attribute.
720 my($self,%attribs) = @_;
722 while (($key,$val) = each %attribs){
723 last unless defined $key;
724 push @m, "$key: $val\n";
731 Takes an array of directories that need to exist and returns a
732 Makefile entry for a .exists file in these directories. Returns
733 nothing, if the entry has already been processed. We're helpless
734 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
735 them get an entry, that's why we use "::".
740 # --- Make-Directories section (internal method) ---
741 # dir_target(@array) returns a Makefile entry for the file .exists in each
742 # named directory. Returns nothing, if the entry has already been processed.
743 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
744 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
745 # prerequisite, because there has to be one, something that doesn't change
748 my($self,@dirs) = @_;
749 my(@m,$dir,$targdir);
750 foreach $dir (@dirs) {
751 my($src) = $self->catfile($self->{PERL_INC},'perl.h');
752 my($targ) = $self->catfile($dir,'.exists');
753 # catfile may have adapted syntax of $dir to target OS, so...
754 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
755 ($targdir = $targ) =~ s:/?\.exists\z::;
757 else { # while elsewhere we expect to see the dir separator in $targ
758 $targdir = dirname($targ);
760 next if $self->{DIR_TARGET}{$self}{$targdir}++;
763 $self->{NOECHO}\$(MKPATH) $targdir
764 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
767 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $targdir
775 Defines a lot of macros for distribution support.
780 my($self, %attribs) = @_;
783 # VERSION should be sanitised before use as a file name
784 my($version) = $attribs{VERSION} || '$(VERSION)';
785 my($name) = $attribs{NAME} || '$(DISTNAME)';
786 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
787 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
788 my($zip) = $attribs{ZIP} || 'zip'; # eg pkzip Yuck!
789 my($zipflags) = $attribs{ZIPFLAGS} || '-r';
790 my($compress) = $attribs{COMPRESS} || 'gzip --best';
791 my($suffix) = $attribs{SUFFIX} || '.gz'; # eg .gz
792 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
793 my($preop) = $attribs{PREOP} || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
794 my($postop) = $attribs{POSTOP} || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
796 my($to_unix) = $attribs{TO_UNIX} || ($Is_OS2
798 . '$(TEST_F) tmp.zip && $(RM) tmp.zip;'
799 . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
800 : "$self->{NOECHO}\$(NOOP)");
802 my($ci) = $attribs{CI} || 'ci -u';
803 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
804 my($dist_cp) = $attribs{DIST_CP} || 'best';
805 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
808 DISTVNAME = ${name}-$version
820 RCS_LABEL = $rcs_label
822 DIST_DEFAULT = $dist_default
827 =item dist_basics (o)
829 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
837 distclean :: realclean distcheck
842 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \\
848 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \\
854 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \\
859 veryclean : realclean
860 $(RM_F) *~ *.orig */*~ */*.orig
867 Defines a check in target for RCS.
876 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \\
877 -e "@all = keys %{ maniread() };" \\
878 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
879 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
886 Defines the targets dist, tardist, zipdist, uutardist, shdist
894 dist : $(DIST_DEFAULT)
895 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
896 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
898 tardist : $(DISTVNAME).tar$(SUFFIX)
900 zipdist : $(DISTVNAME).zip
902 $(DISTVNAME).tar$(SUFFIX) : distdir
905 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
906 $(RM_RF) $(DISTVNAME)
907 $(COMPRESS) $(DISTVNAME).tar
910 $(DISTVNAME).zip : distdir
912 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
913 $(RM_RF) $(DISTVNAME)
916 uutardist : $(DISTVNAME).tar$(SUFFIX)
917 uuencode $(DISTVNAME).tar$(SUFFIX) \\
918 $(DISTVNAME).tar$(SUFFIX) > \\
919 $(DISTVNAME).tar$(SUFFIX)_uu
923 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
924 $(RM_RF) $(DISTVNAME)
932 Defines the scratch directory target that will hold the distribution
933 before tar-ing (or shar-ing).
942 $(RM_RF) $(DISTVNAME)
943 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
944 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
951 Defines a target that produces the distribution in the
952 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
962 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
963 cd $(DISTVNAME) && $(MAKE)
964 cd $(DISTVNAME) && $(MAKE) test
971 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
977 my($self,%attribs) = @_;
979 return '' unless ($^O eq 'aix' && $self->needs_linking() );
981 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
982 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
983 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
987 dynamic :: $self->{BASEEXT}.exp
989 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
992 static :: $self->{BASEEXT}.exp
994 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
997 $self->{BASEEXT}.exp: Makefile.PL
998 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
999 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
1000 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
1001 ', "DL_VARS" => ', neatvalue($vars), ');\'
1009 Defines the dynamic target.
1014 # --- Dynamic Loading Sections ---
1018 ## $(INST_PM) has been moved to the all: target.
1019 ## It remains here for awhile to allow for old usage: "make dynamic"
1020 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
1021 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
1022 '.$self->{NOECHO}.'$(NOOP)
1026 =item dynamic_bs (o)
1028 Defines targets for bootstrap files.
1033 my($self, %attribs) = @_;
1036 ' unless $self->has_link_code();
1039 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
1041 # As Mkbootstrap might not write a file (if none is required)
1042 # we use touch to prevent make continually trying to remake it.
1043 # The DynaLoader only reads a non-empty file.
1044 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
1045 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1046 '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
1047 -MExtUtils::Mkbootstrap \
1048 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
1049 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
1050 $(CHMOD) $(PERM_RW) $@
1052 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
1053 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
1054 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
1055 $(CHMOD) $(PERM_RW) $@
1059 =item dynamic_lib (o)
1061 Defines how to produce the *.so (or equivalent) files.
1066 my($self, %attribs) = @_;
1067 return '' unless $self->needs_linking(); #might be because of a subdir
1069 return '' unless $self->has_link_code;
1071 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1072 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1073 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1074 my($ldfrom) = '$(LDFROM)';
1075 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
1078 # This section creates the dynamically loadable $(INST_DYNAMIC)
1079 # from $(OBJECT) and possibly $(MYEXTLIB).
1080 ARMAYBE = '.$armaybe.'
1081 OTHERLDFLAGS = '.$otherldflags.'
1082 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1084 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
1086 if ($armaybe ne ':'){
1087 $ldfrom = 'tmp$(LIB_EXT)';
1088 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1089 push(@m,' $(RANLIB) '."$ldfrom\n");
1091 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1093 # The IRIX linker doesn't use LD_RUN_PATH
1094 my $ldrun = qq{-rpath "$self->{LD_RUN_PATH}"}
1095 if ($^O eq 'irix' && $self->{LD_RUN_PATH});
1097 # For example in AIX the shared objects/libraries from previous builds
1098 # linger quite a while in the shared dynalinker cache even when nobody
1099 # is using them. This is painful if one for instance tries to restart
1100 # a failed build because the link command will fail unnecessarily 'cos
1101 # the shared object/library is 'busy'.
1102 push(@m,' $(RM_F) $@
1105 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1106 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST)');
1108 $(CHMOD) $(PERM_RWX) $@
1111 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1117 Deprecated method. Use libscan instead.
1122 my($self,$path) = @_;
1128 Called by init_others, and calls ext ExtUtils::Liblist. See
1129 L<ExtUtils::Liblist> for details.
1134 my($self,$libs) = @_;
1135 require ExtUtils::Liblist;
1136 $self->ext($libs, $Verbose);
1139 =item file_name_is_absolute
1141 Takes as argument a path and returns true, if it is an absolute path.
1145 sub file_name_is_absolute {
1146 my($self,$file) = @_;
1148 $file =~ m{^([a-z]:)?[\\/]}is ;
1157 Finds the executables PERL and FULLPERL
1162 my($self, $ver, $names, $dirs, $trace) = @_;
1165 print "Looking for perl $ver by these names:
1171 foreach $name (@$names){
1172 foreach $dir (@$dirs){
1173 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1175 if ($self->file_name_is_absolute($name)) { # /foo/bar
1177 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1178 $abs = $self->catfile($dir, $name);
1180 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1182 print "Checking $abs\n" if ($trace >= 2);
1183 next unless $self->maybe_command($abs);
1184 print "Executing $abs\n" if ($trace >= 2);
1185 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1186 if ($val =~ /VER_OK/) {
1187 print "Using PERL=$abs\n" if $trace;
1189 } elsif ($trace >= 2) {
1190 print "Result: `$val'\n";
1194 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1195 0; # false and not empty
1200 =head2 Methods to actually produce chunks of text for the Makefile
1202 The methods here are called for each MakeMaker object in the order
1203 specified by @ExtUtils::MakeMaker::MM_Sections.
1209 Inserts the sharpbang or equivalent magic number to a script
1213 sub fixin { # stolen from the pink Camel book, more or less
1214 my($self,@files) = @_;
1215 my($does_shbang) = $Config::Config{'sharpbang'} =~ /^\s*\#\!/;
1216 my($file,$interpreter);
1217 for $file (@files) {
1220 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1222 chomp(my $line = <FIXIN>);
1223 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1224 # Now figure out the interpreter name.
1225 my($cmd,$arg) = split ' ', $line, 2;
1228 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1229 if ($cmd eq "perl") {
1230 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1231 $interpreter = $Config{startperl};
1232 $interpreter =~ s,^\#!,,;
1234 $interpreter = $Config{perlpath};
1237 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1240 foreach $dir (@absdirs) {
1241 if ($self->maybe_command($cmd)) {
1242 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1243 $interpreter = $self->catfile($dir,$cmd);
1247 # Figure out how to invoke interpreter on this machine.
1251 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1252 # this is probably value-free on DOSISH platforms
1254 $shb .= "$Config{'sharpbang'}$interpreter";
1255 $shb .= ' ' . $arg if defined $arg;
1259 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1260 if 0; # not running under some shell
1261 } unless $Is_Win32; # this won't work on win32, so don't
1263 warn "Can't find $cmd in PATH, $file unchanged"
1268 unless ( open(FIXOUT,">$file.new") ) {
1269 warn "Can't create new $file: $!\n";
1272 my($dev,$ino,$mode) = stat FIXIN;
1274 # Print out the new #! line (or equivalent).
1277 print FIXOUT $shb, <FIXIN>;
1281 # can't rename/chmod open files on some DOSISH platforms
1283 # If they override perm_rwx, we won't notice it during fixin,
1284 # because fixin is run through a new instance of MakeMaker.
1285 # That is why we must run another CHMOD later.
1286 $mode = oct($self->perm_rwx) unless $dev;
1289 unless ( rename($file, "$file.bak") ) {
1290 warn "Can't rename $file to $file.bak: $!";
1293 unless ( rename("$file.new", $file) ) {
1294 warn "Can't rename $file.new to $file: $!";
1295 unless ( rename("$file.bak", $file) ) {
1296 warn "Can't rename $file.bak back to $file either: $!";
1297 warn "Leaving $file renamed as $file.bak\n";
1303 close(FIXIN) if fileno(FIXIN);
1304 chmod oct($self->perm_rwx), $file or
1305 die "Can't reset permissions for $file: $!\n";
1306 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1318 '# Phony target to force checking subdirectories.
1320 '.$self->{NOECHO}.'$(NOOP)
1326 Guess the name of this package by examining the working directory's
1327 name. MakeMaker calls this only if the developer has not supplied a
1337 my $name = basename(cwd());
1338 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1339 # strip minus or underline
1340 # followed by a float or some such
1341 print "Warning: Guessing NAME [$name] from current directory name.\n";
1347 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1348 object that need a compiler. Does not descend into subdirectories as
1349 needs_linking() does.
1355 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1356 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1357 $self->{HAS_LINK_CODE} = 1;
1360 return $self->{HAS_LINK_CODE} = 0;
1363 =item htmlifypods (o)
1365 Defines targets and routines to translate the pods into HTML manpages
1366 and put them into the INST_HTMLLIBDIR and INST_HTMLSCRIPTDIR
1372 my($self, %attribs) = @_;
1373 return "\nhtmlifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
1374 %{$self->{HTMLLIBPODS}} || %{$self->{HTMLSCRIPTPODS}};
1377 if (defined $self->{PERL_SRC}) {
1378 $pod2html_exe = $self->catfile($self->{PERL_SRC},'pod','pod2html');
1380 $pod2html_exe = $self->catfile($Config{scriptdirexp},'pod2html');
1382 unless ($pod2html_exe = $self->perl_script($pod2html_exe)) {
1383 # No pod2html but some HTMLxxxPODS to be installed
1386 Warning: I could not locate your pod2html program. Please make sure,
1387 your pod2html program is in your PATH before you execute 'make'
1390 $pod2html_exe = "-S pod2html";
1394 qq[POD2HTML_EXE = $pod2html_exe\n],
1395 qq[POD2HTML = \$(PERL) -we 'use File::Basename; use File::Path qw(mkpath); %m=\@ARGV;for (keys %m){' \\\n],
1396 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
1397 $self->{MAKEFILE}, q[";' \\
1398 -e 'print "Htmlifying $$m{$$_}\n";' \\
1399 -e '$$dir = dirname($$m{$$_}); mkpath($$dir) unless -d $$dir;' \\
1400 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2HTML_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
1401 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
1403 push @m, "\nhtmlifypods : pure_all ";
1404 push @m, join " \\\n\t", keys %{$self->{HTMLLIBPODS}}, keys %{$self->{HTMLSCRIPTPODS}};
1407 if (%{$self->{HTMLLIBPODS}} || %{$self->{HTMLSCRIPTPODS}}) {
1408 push @m, "\t$self->{NOECHO}\$(POD2HTML) \\\n\t";
1409 push @m, join " \\\n\t", %{$self->{HTMLLIBPODS}}, %{$self->{HTMLSCRIPTPODS}};
1416 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, HTML*PODS, MAN*PODS, EXE_FILES.
1420 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1422 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1423 local(%pm); #the sub in find() has to see this hash
1424 @ignore{qw(Makefile.PL test.pl)} = (1,1);
1425 $ignore{'makefile.pl'} = 1 if $Is_VMS;
1426 foreach $name ($self->lsdir($self->curdir)){
1427 next if $name =~ /\#/;
1428 next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1429 next unless $self->libscan($name);
1431 next if -l $name; # We do not support symlinks at all
1432 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1433 } elsif ($name =~ /\.xs\z/){
1434 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1437 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1439 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1440 } elsif ($name =~ /\.h\z/i){
1442 } elsif ($name =~ /\.PL\z/) {
1443 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1444 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1445 # case-insensitive filesystem, one dot per name, so foo.h.PL
1446 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1447 local($/); open(PL,$name); my $txt = <PL>; close PL;
1448 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1449 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1451 else { $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name); }
1452 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1453 $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1457 # Some larger extensions often wish to install a number of *.pm/pl
1458 # files into the library in various locations.
1460 # The attribute PMLIBDIRS holds an array reference which lists
1461 # subdirectories which we should search for library files to
1462 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1463 # recursively search through the named directories (skipping any
1464 # which don't exist or contain Makefile.PL files).
1466 # For each *.pm or *.pl file found $self->libscan() is called with
1467 # the default installation path in $_[1]. The return value of
1468 # libscan defines the actual installation location. The default
1469 # libscan function simply returns the path. The file is skipped
1470 # if libscan returns false.
1472 # The default installation location passed to libscan in $_[1] is:
1474 # ./*.pm => $(INST_LIBDIR)/*.pm
1475 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1476 # ./lib/... => $(INST_LIB)/...
1478 # In this way the 'lib' directory is seen as the root of the actual
1479 # perl library whereas the others are relative to INST_LIBDIR
1480 # (which includes PARENT_NAME). This is a subtle distinction but one
1481 # that's important for nested modules.
1483 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1484 unless $self->{PMLIBDIRS};
1486 #only existing directories that aren't in $dir are allowed
1488 # Avoid $_ wherever possible:
1489 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1490 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1492 @{$self->{PMLIBDIRS}} = ();
1493 foreach $pmlibdir (@pmlibdirs) {
1494 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1497 if (@{$self->{PMLIBDIRS}}){
1498 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1501 File::Find::find(sub {
1503 if ($_ eq "CVS" || $_ eq "RCS"){
1504 $File::Find::prune = 1;
1509 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1510 my($striplibpath,$striplibname);
1511 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1512 ($striplibname,$striplibpath) = fileparse($striplibpath);
1513 my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1514 local($_) = $inst; # for backwards compatibility
1515 $inst = $self->libscan($inst);
1516 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1517 return unless $inst;
1519 }, @{$self->{PMLIBDIRS}});
1522 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1523 $self->{XS} = \%xs unless $self->{XS};
1524 $self->{PM} = \%pm unless $self->{PM};
1525 $self->{C} = [sort keys %c] unless $self->{C};
1526 my(@o_files) = @{$self->{C}};
1527 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files] ;
1528 $self->{H} = [sort keys %h] unless $self->{H};
1529 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1531 # Set up names of manual pages to generate from pods
1533 foreach my $man (qw(MAN1 MAN3 HTMLLIB HTMLSCRIPT)) {
1534 unless ($self->{"${man}PODS"}) {
1535 $self->{"${man}PODS"} = {};
1536 $pods{$man} = 1 unless $self->{"INST_${man}DIR"} =~ /^(none|\s*)$/;
1540 if ($pods{MAN1} || $pods{HTMLSCRIPT}) {
1541 if ( exists $self->{EXE_FILES} ) {
1542 foreach $name (@{$self->{EXE_FILES}}) {
1545 if (open(FH,"<$name")) {
1547 if (/^=head1\s+\w+/) {
1554 # If it doesn't exist yet, we assume, it has pods in it
1558 if ($pods{HTMLSCRIPT}) {
1559 $self->{HTMLSCRIPTPODS}->{$name} =
1560 $self->catfile("\$(INST_HTMLSCRIPTDIR)", basename($name).".\$(HTMLEXT)");
1563 $self->{MAN1PODS}->{$name} =
1564 $self->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1569 if ($pods{MAN3} || $pods{HTMLLIB}) {
1570 my %manifypods = (); # we collect the keys first, i.e. the files
1571 # we have to convert to pod
1572 foreach $name (keys %{$self->{PM}}) {
1573 if ($name =~ /\.pod\z/ ) {
1574 $manifypods{$name} = $self->{PM}{$name};
1575 } elsif ($name =~ /\.p[ml]\z/ ) {
1578 if (open(FH,"<$name")) {
1580 if (/^=head1\s+\w+/) {
1590 $manifypods{$name} = $self->{PM}{$name};
1595 # Remove "Configure.pm" and similar, if it's not the only pod listed
1596 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1597 foreach $name (keys %manifypods) {
1598 if ($name =~ /(config|setup).*\.pm/is) {
1599 delete $manifypods{$name};
1602 my($manpagename) = $name;
1603 $manpagename =~ s/\.p(od|m|l)\z//;
1604 if ($pods{HTMLLIB}) {
1605 $self->{HTMLLIBPODS}->{$name} =
1606 $self->catfile("\$(INST_HTMLLIBDIR)", "$manpagename.\$(HTMLEXT)");
1608 unless ($manpagename =~ s!^\W*lib\W+!!s) { # everything below lib is ok
1609 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1612 $manpagename = $self->replace_manpage_separator($manpagename);
1613 $self->{MAN3PODS}->{$name} =
1614 $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1622 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1623 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1624 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1625 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1632 # --- Initialize Module Name and Paths
1634 # NAME = Foo::Bar::Oracle
1635 # FULLEXT = Foo/Bar/Oracle
1637 # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1638 # PARENT_NAME = Foo::Bar
1640 ### ($self->{FULLEXT} =
1641 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1642 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1645 # Copied from DynaLoader:
1647 my(@modparts) = split(/::/,$self->{NAME});
1648 my($modfname) = $modparts[-1];
1650 # Some systems have restrictions on files names for DLL's etc.
1651 # mod2fname returns appropriate file base name (typically truncated)
1652 # It may also edit @modparts if required.
1653 if (defined &DynaLoader::mod2fname) {
1654 $modfname = &DynaLoader::mod2fname(\@modparts);
1657 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1659 if (defined &DynaLoader::mod2fname) {
1660 # As of 5.001m, dl_os2 appends '_'
1661 $self->{DLBASE} = $modfname;
1663 $self->{DLBASE} = '$(BASEEXT)';
1667 ### ROOTEXT deprecated from MM 5.32
1668 ### ($self->{ROOTEXT} =
1669 ### $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
1670 ### $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1673 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1675 # *Real* information: where did we get these two from? ...
1676 my $inc_config_dir = dirname($INC{'Config.pm'});
1677 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1679 unless ($self->{PERL_SRC}){
1681 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())){
1683 -f $self->catfile($dir,"config.sh")
1685 -f $self->catfile($dir,"perl.h")
1687 -f $self->catfile($dir,"lib","Exporter.pm")
1689 $self->{PERL_SRC}=$dir ;
1694 if ($self->{PERL_SRC}){
1695 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1696 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1697 $self->{PERL_INC} = ($Is_Win32) ? $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1699 # catch a situation that has occurred a few times in the past:
1701 -s $self->catfile($self->{PERL_SRC},'cflags')
1705 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1712 You cannot build extensions below the perl source tree after executing
1713 a 'make clean' in the perl source tree.
1715 To rebuild extensions distributed with the perl source you should
1716 simply Configure (to include those extensions) and then build perl as
1717 normal. After installing perl the source tree can be deleted. It is
1718 not needed for building extensions by running 'perl Makefile.PL'
1719 usually without extra arguments.
1721 It is recommended that you unpack and build additional extensions away
1722 from the perl source tree.
1726 # we should also consider $ENV{PERL5LIB} here
1727 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1728 $self->{PERL_LIB} ||= $Config::Config{privlibexp};
1729 $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1730 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1733 no warnings 'uninitialized' ;
1734 if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
1736 # Maybe somebody tries to build an extension with an
1737 # uninstalled Perl outside of Perl build tree
1739 for my $dir (@INC) {
1740 $found = $dir, last if -e $self->catdir($dir, "Config.pm");
1743 my $inc = dirname $found;
1744 if (-e $self->catdir($inc, "perl.h")) {
1745 $self->{PERL_LIB} = $found;
1746 $self->{PERL_ARCHLIB} = $found;
1747 $self->{PERL_INC} = $inc;
1748 $self->{UNINSTALLED_PERL} = 1;
1750 ... Detected uninstalled Perl. Trying to continue.
1756 unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1758 Error: Unable to locate installed Perl libraries or Perl source code.
1760 It is recommended that you install perl in a standard location before
1761 building extensions. Some precompiled versions of perl do not contain
1762 these header files, so you cannot build extensions. In such a case,
1763 please build and install your perl from a fresh perl distribution. It
1764 usually solves this kind of problem.
1766 \(You get this message, because MakeMaker could not find "$perl_h"\)
1769 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1770 # if $Verbose && $self->needs_linking();
1774 # We get SITELIBEXP and SITEARCHEXP directly via
1775 # Get_from_Config. When we are running standard modules, these
1776 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1777 # set it to "site". I prefer that INSTALLDIRS be set from outside
1779 $self->{INSTALLDIRS} ||= "site";
1781 # INST_LIB typically pre-set if building an extension after
1782 # perl has been built and installed. Setting INST_LIB allows
1783 # you to build directly into, say $Config::Config{privlibexp}.
1784 unless ($self->{INST_LIB}){
1787 ##### XXXXX We have to change this nonsense
1789 if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1790 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1792 $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1795 $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1796 $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1798 # We need to set up INST_LIBDIR before init_libscan() for VMS
1799 my @parentdir = split(/::/, $self->{PARENT_NAME});
1800 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1801 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1802 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1803 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1805 # INST_EXE is deprecated, should go away March '97
1806 $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1807 $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1809 # The user who requests an installation directory explicitly
1810 # should not have to tell us a architecture installation directory
1811 # as well. We look if a directory exists that is named after the
1812 # architecture. If not we take it as a sign that it should be the
1813 # same as the requested installation directory. Otherwise we take
1815 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1817 for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1818 my $lib = "install$libpair->{l}";
1820 my $Arch = uc "install$libpair->{a}";
1821 if( $self->{$Lib} && ! $self->{$Arch} ){
1822 my($ilib) = $Config{$lib};
1823 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1825 $self->prefixify($Arch,$ilib,$self->{$Lib});
1827 unless (-d $self->{$Arch}) {
1828 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1829 $self->{$Arch} = $self->{$Lib};
1831 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1835 # we have to look at the relation between $Config{prefix} and the
1836 # requested values. We're going to set the $Config{prefix} part of
1837 # all the installation path variables to literally $(PREFIX), so
1838 # the user can still say make PREFIX=foo
1839 my($configure_prefix) = $Config{'prefix'};
1840 $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1841 $self->{PREFIX} ||= $configure_prefix;
1844 my($install_variable,$search_prefix,$replace_prefix);
1846 # If the prefix contains perl, Configure shapes the tree as follows:
1847 # perlprefix/lib/ INSTALLPRIVLIB
1848 # perlprefix/lib/pod/
1849 # perlprefix/lib/site_perl/ INSTALLSITELIB
1850 # perlprefix/bin/ INSTALLBIN
1851 # perlprefix/man/ INSTALLMAN1DIR
1853 # prefix/lib/perl5/ INSTALLPRIVLIB
1854 # prefix/lib/perl5/pod/
1855 # prefix/lib/perl5/site_perl/ INSTALLSITELIB
1856 # prefix/bin/ INSTALLBIN
1857 # prefix/lib/perl5/man/ INSTALLMAN1DIR
1859 # The above results in various kinds of breakage on various
1860 # platforms, so we cope with it as follows: if prefix/lib/perl5
1861 # or prefix/lib/perl5/man exist, we'll replace those instead
1862 # of /prefix/{lib,man}
1864 $replace_prefix = qq[\$\(PREFIX\)];
1865 for $install_variable (qw/
1869 $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1871 my $funkylibdir = $self->catdir($configure_prefix,"lib","perl5");
1872 $funkylibdir = '' unless -d $funkylibdir;
1873 $search_prefix = $funkylibdir || $self->catdir($configure_prefix,"lib");
1875 $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1876 $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1877 $self->catdir($self->{LIB},$Config{'archname'});
1880 if (-d $self->catdir($self->{PREFIX},"lib","perl5")) {
1881 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib", "perl5");
1884 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib");
1886 for $install_variable (qw/
1893 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1896 my $funkymandir = $self->catdir($configure_prefix,"lib","perl5","man");
1897 $funkymandir = '' unless -d $funkymandir;
1898 $search_prefix = $funkymandir || $self->catdir($configure_prefix,"man");
1899 if (-d $self->catdir($self->{PREFIX},"lib","perl5", "man")) {
1900 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"lib", "perl5", "man");
1903 $replace_prefix = $self->catdir(qq[\$\(PREFIX\)],"man");
1905 for $install_variable (qw/
1910 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1913 # Now we head at the manpages. Maybe they DO NOT want manpages
1915 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1916 unless defined $self->{INSTALLMAN1DIR};
1917 unless (defined $self->{INST_MAN1DIR}){
1918 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1919 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1921 $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1924 $self->{MAN1EXT} ||= $Config::Config{man1ext};
1926 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1927 unless defined $self->{INSTALLMAN3DIR};
1928 unless (defined $self->{INST_MAN3DIR}){
1929 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1930 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1932 $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1935 $self->{MAN3EXT} ||= $Config::Config{man3ext};
1937 $self->{INSTALLHTMLPRIVLIBDIR} = $Config::Config{installhtmlprivlibdir}
1938 unless defined $self->{INSTALLHTMLPRIVLIBDIR};
1939 $self->{INSTALLHTMLSITELIBDIR} = $Config::Config{installhtmlsitelibdir}
1940 unless defined $self->{INSTALLHTMLSITELIBDIR};
1942 unless (defined $self->{INST_HTMLLIBDIR}){
1943 if ($self->{INSTALLHTMLSITELIBDIR} =~ /^(none|\s*)$/){
1944 $self->{INST_HTMLLIBDIR} = $self->{INSTALLHTMLSITELIBDIR};
1946 $self->{INST_HTMLLIBDIR} = $self->catdir($self->curdir,'blib','html','lib');
1950 $self->{INSTALLHTMLSCRIPTDIR} = $Config::Config{installhtmlscriptdir}
1951 unless defined $self->{INSTALLHTMLSCRIPTDIR};
1952 unless (defined $self->{INST_HTMLSCRIPTDIR}){
1953 if ($self->{INSTALLHTMLSCRIPTDIR} =~ /^(none|\s*)$/){
1954 $self->{INST_HTMLSCRIPTDIR} = $self->{INSTALLHTMLSCRIPTDIR};
1956 $self->{INST_HTMLSCRIPTDIR} = $self->catdir($self->curdir,'blib','html','bin');
1959 $self->{HTMLEXT} ||= $Config::Config{htmlext} || 'html';
1962 # Get some stuff out of %Config if we haven't yet done so
1963 print STDOUT "CONFIG must be an array ref\n"
1964 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1965 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1966 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1967 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1969 foreach $m (@{$self->{CONFIG}}){
1970 next if $once_only{$m};
1971 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1972 unless exists $Config::Config{$m};
1973 $self->{uc $m} ||= $Config::Config{$m};
1977 # This is too dangerous:
1978 # if ($^O eq "next") {
1979 # $self->{AR} = "libtool";
1980 # $self->{AR_STATIC_ARGS} = "-o";
1982 # But I leave it as a placeholder
1984 $self->{AR_STATIC_ARGS} ||= "cr";
1986 # These should never be needed
1987 $self->{LD} ||= 'ld';
1988 $self->{OBJ_EXT} ||= '.o';
1989 $self->{LIB_EXT} ||= '.a';
1991 $self->{MAP_TARGET} ||= "perl";
1993 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1995 # make a simple check if we find Exporter
1996 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1997 (Exporter.pm not found)"
1998 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1999 $self->{NAME} eq "ExtUtils::MakeMaker";
2001 # Determine VERSION and VERSION_FROM
2002 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
2003 if ($self->{VERSION_FROM}){
2004 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
2005 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
2009 if ($self->{VERSION}) {
2010 $self->{VERSION} =~ s/^\s+//;
2011 $self->{VERSION} =~ s/\s+$//;
2014 $self->{VERSION} ||= "0.10";
2015 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
2018 # Graham Barr and Paul Marquess had some ideas how to ensure
2019 # version compatibility between the *.pm file and the
2020 # corresponding *.xs file. The bottomline was, that we need an
2021 # XS_VERSION macro that defaults to VERSION:
2022 $self->{XS_VERSION} ||= $self->{VERSION};
2024 # --- Initialize Perl Binary Locations
2026 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
2027 # will be working versions of perl 5. miniperl has priority over perl
2028 # for PERL to ensure that $(PERL) is usable while building ./ext/*
2029 my ($component,@defpath);
2030 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
2031 push @defpath, $component if defined $component;
2034 $self->find_perl(5.0, [ $self->canonpath($^X), 'miniperl',
2035 'perl','perl5',"perl$Config{version}" ],
2036 \@defpath, $Verbose );
2037 # don't check if perl is executable, maybe they have decided to
2038 # supply switches with perl
2040 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2041 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
2042 unless ($self->{FULLPERL});
2047 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
2048 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
2049 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
2053 sub init_others { # --- Initialize Other Attributes
2056 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
2057 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
2058 # undefined. In any case we turn it into an anon array:
2060 # May check $Config{libs} too, thus not empty.
2061 $self->{LIBS}=[''] unless $self->{LIBS};
2063 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
2064 $self->{LD_RUN_PATH} = "";
2066 foreach $libs ( @{$self->{LIBS}} ){
2067 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
2068 my(@libs) = $self->extliblist($libs);
2069 if ($libs[0] or $libs[1] or $libs[2]){
2070 # LD_RUN_PATH now computed by ExtUtils::Liblist
2071 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
2076 if ( $self->{OBJECT} ) {
2077 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
2079 # init_dirscan should have found out, if we have C files
2080 $self->{OBJECT} = "";
2081 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
2083 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
2084 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
2085 $self->{PERLMAINCC} ||= '$(CC)';
2086 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
2088 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
2089 # the 'dynamic' section of MM. We don't have this problem with
2090 # 'static', since we either must use it (%Config says we can't
2091 # use dynamic loading) or the caller asked for it explicitly.
2092 if (!$self->{LINKTYPE}) {
2093 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
2095 : ($Config::Config{usedl} ? 'dynamic' : 'static');
2098 # These get overridden for VMS and maybe some other systems
2099 $self->{NOOP} ||= '$(SHELL) -c true';
2100 $self->{FIRST_MAKEFILE} ||= "Makefile";
2101 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
2102 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
2103 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
2104 $self->{RM_F} ||= "rm -f";
2105 $self->{RM_RF} ||= "rm -rf";
2106 $self->{TOUCH} ||= "touch";
2107 $self->{TEST_F} ||= "test -f";
2108 $self->{CP} ||= "cp";
2109 $self->{MV} ||= "mv";
2110 $self->{CHMOD} ||= "chmod";
2111 $self->{UMASK_NULL} ||= "umask 0";
2112 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
2117 Defines the install target.
2122 my($self, %attribs) = @_;
2126 install :: all pure_install doc_install
2128 install_perl :: all pure_perl_install doc_perl_install
2130 install_site :: all pure_site_install doc_site_install
2132 install_ :: install_site
2133 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2135 pure_install :: pure_$(INSTALLDIRS)_install
2137 doc_install :: doc_$(INSTALLDIRS)_install
2138 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2140 pure__install : pure_site_install
2141 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2143 doc__install : doc_site_install
2144 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2146 pure_perl_install ::
2147 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2148 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2149 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2150 $(INST_LIB) $(INSTALLPRIVLIB) \
2151 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2152 $(INST_BIN) $(INSTALLBIN) \
2153 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2154 $(INST_HTMLLIBDIR) $(INSTALLHTMLPRIVLIBDIR) \
2155 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2156 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2157 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2158 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2159 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2162 pure_site_install ::
2163 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2164 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2165 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2166 $(INST_LIB) $(INSTALLSITELIB) \
2167 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2168 $(INST_BIN) $(INSTALLBIN) \
2169 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2170 $(INST_HTMLLIBDIR) $(INSTALLHTMLSITELIBDIR) \
2171 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2172 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2173 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2174 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2175 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2178 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2179 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2180 "Module" "$(NAME)" \
2181 "installed into" "$(INSTALLPRIVLIB)" \
2182 LINKTYPE "$(LINKTYPE)" \
2183 VERSION "$(VERSION)" \
2184 EXE_FILES "$(EXE_FILES)" \
2185 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2188 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2189 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2190 "Module" "$(NAME)" \
2191 "installed into" "$(INSTALLSITELIB)" \
2192 LINKTYPE "$(LINKTYPE)" \
2193 VERSION "$(VERSION)" \
2194 EXE_FILES "$(EXE_FILES)" \
2195 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2200 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2202 uninstall_from_perldirs ::
2204 q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2206 uninstall_from_sitedirs ::
2208 q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2214 =item installbin (o)
2216 Defines targets to make and to install EXE_FILES.
2222 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2223 return "" unless @{$self->{EXE_FILES}};
2224 my(@m, $from, $to, %fromto, @to);
2225 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2226 for $from (@{$self->{EXE_FILES}}) {
2227 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2228 local($_) = $path; # for backwards compatibility
2229 $to = $self->libscan($path);
2230 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2233 @to = values %fromto;
2235 EXE_FILES = @{$self->{EXE_FILES}}
2238 ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2239 -e "system qq[pl2bat.bat ].shift"
2240 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2241 -e "MY->fixin(shift)"
2244 $self->{NOECHO}\$(NOOP)
2250 while (($from,$to) = each %fromto) {
2251 last unless defined $from;
2252 my $todir = dirname($to);
2254 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2255 $self->{NOECHO}$self->{RM_F} $to
2256 $self->{CP} $from $to
2258 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2266 Takes a path to a file that is found by init_dirscan and returns false
2267 if we don't want to include this file in the library. Mainly used to
2268 exclude RCS, CVS, and SCCS directories from installation.
2275 my($self,$path) = @_;
2276 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2282 Defines the linkext target which in turn defines the LINKTYPE.
2287 my($self, %attribs) = @_;
2288 # LINKTYPE => static or dynamic or ''
2289 my($linktype) = defined $attribs{LINKTYPE} ?
2290 $attribs{LINKTYPE} : '$(LINKTYPE)';
2292 linkext :: $linktype
2293 $self->{NOECHO}\$(NOOP)
2299 Takes as arguments a directory name and a regular expression. Returns
2300 all entries in the directory that match the regular expression.
2306 my($dir, $regex) = @_;
2308 my $dh = new DirHandle;
2309 $dh->open($dir || ".") or return ();
2312 @ls = grep(/$regex/, @ls) if $regex;
2318 Simple subroutine to insert the macros defined by the macro attribute
2324 my($self,%attribs) = @_;
2326 while (($key,$val) = each %attribs){
2327 last unless defined $key;
2328 push @m, "$key = $val\n";
2335 Called by staticmake. Defines how to write the Makefile to produce a
2338 By default the Makefile produced includes all the static extensions in
2339 the perl library. (Purified versions of library files, e.g.,
2340 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2345 my($self, %attribs) = @_;
2346 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2347 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2350 # --- MakeMaker makeaperl section ---
2351 MAP_TARGET = $target
2352 FULLPERL = $self->{FULLPERL}
2354 return join '', @m if $self->{PARENT};
2356 my($dir) = join ":", @{$self->{DIR}};
2358 unless ($self->{MAKEAPERL}) {
2360 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2361 $(MAKE) -f $(MAKE_APERL_FILE) $@
2363 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2364 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2365 }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2366 Makefile.PL DIR=}, $dir, q{ \
2367 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2368 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2374 push @m, " \\\n\t\t$_";
2376 # push @m, map( " \\\n\t\t$_", @ARGV );
2384 my($cccmd, $linkcmd, $lperl);
2387 $cccmd = $self->const_cccmd($libperl);
2388 $cccmd =~ s/^CCCMD\s*=\s*//;
2389 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2390 $cccmd .= " $Config::Config{cccdlflags}"
2391 if ($Config::Config{useshrplib} eq 'true');
2392 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2394 # The front matter of the linkcommand...
2395 $linkcmd = join ' ', "\$(CC)",
2396 grep($_, @Config{qw(ldflags ccdlflags)});
2397 $linkcmd =~ s/\s+/ /g;
2398 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2400 # Which *.a files could we make use of...
2403 File::Find::find(sub {
2404 return unless m/\Q$self->{LIB_EXT}\E$/;
2405 return if m/^libperl/;
2406 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2407 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2409 if( exists $self->{INCLUDE_EXT} ){
2414 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2418 # Throw away anything not explicitly marked for inclusion.
2419 # DynaLoader is implied.
2420 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2426 return unless $found;
2428 elsif( exists $self->{EXCLUDE_EXT} ){
2432 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2436 # Throw away anything explicitly marked for exclusion
2437 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2438 return if( $xx eq $excl );
2442 # don't include the installed version of this extension. I
2443 # leave this line here, although it is not necessary anymore:
2444 # I patched minimod.PL instead, so that Miniperl.pm won't
2445 # enclude duplicates
2447 # Once the patch to minimod.PL is in the distribution, I can
2449 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2451 $static{cwd() . "/" . $_}++;
2452 }, grep( -d $_, @{$searchdirs || []}) );
2454 # We trust that what has been handed in as argument, will be buildable
2455 $static = [] unless $static;
2456 @static{@{$static}} = (1) x @{$static};
2458 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2459 for (sort keys %static) {
2460 next unless /\Q$self->{LIB_EXT}\E\z/;
2461 $_ = dirname($_) . "/extralibs.ld";
2465 grep(s/^/-I/, @{$perlinc || []});
2467 $target = "perl" unless $target;
2468 $tmp = "." unless $tmp;
2470 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2471 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2472 # extralibs.all are computed correctly
2474 MAP_LINKCMD = $linkcmd
2475 MAP_PERLINC = @{$perlinc || []}
2477 join(" \\\n\t", reverse sort keys %static), "
2479 MAP_PRELIBS = $Config::Config{perllibs} $Config::Config{cryptlib}
2482 if (defined $libperl) {
2483 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2485 unless ($libperl && -f $lperl) { # Ilya's code...
2486 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2487 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2488 $libperl ||= "libperl$self->{LIB_EXT}";
2489 $libperl = "$dir/$libperl";
2490 $lperl ||= "libperl$self->{LIB_EXT}";
2491 $lperl = "$dir/$lperl";
2493 if (! -f $libperl and ! -f $lperl) {
2494 # We did not find a static libperl. Maybe there is a shared one?
2495 if ($^O eq 'solaris' or $^O eq 'sunos') {
2496 $lperl = $libperl = "$dir/$Config::Config{libperl}";
2497 # SUNOS ld does not take the full path to a shared library
2498 $libperl = '' if $^O eq 'sunos';
2502 print STDOUT "Warning: $libperl not found
2503 If you're going to build a static perl binary, make sure perl is installed
2504 otherwise ignore this warning\n"
2505 unless (-f $lperl || defined($self->{PERL_SRC}));
2509 MAP_LIBPERL = $libperl
2513 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2514 $self->{NOECHO}$self->{RM_F} \$\@
2515 $self->{NOECHO}\$(TOUCH) \$\@
2519 foreach $catfile (@$extra){
2520 push @m, "\tcat $catfile >> \$\@\n";
2522 # SUNOS ld does not take the full path to a shared library
2523 my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2526 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2527 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) $llibperl `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2528 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2529 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2530 $self->{NOECHO}echo 'To remove the intermediate files say'
2531 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2533 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2535 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2538 $tmp/perlmain.c: $makefilename}, q{
2539 }.$self->{NOECHO}.q{echo Writing $@
2540 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2541 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2544 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2545 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2550 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2551 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2552 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2553 "Perl binary" "$(MAP_TARGET)" \
2554 MAP_STATIC "$(MAP_STATIC)" \
2555 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2556 MAP_LIBPERL "$(MAP_LIBPERL)" \
2557 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2562 inst_perl: pure_inst_perl doc_inst_perl
2564 pure_inst_perl: $(MAP_TARGET)
2565 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2570 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2578 Defines how to rewrite the Makefile.
2585 # We do not know what target was originally specified so we
2586 # must force a manual rerun to be sure. But as it should only
2587 # happen very rarely it is not a significant problem.
2589 $(OBJECT) : $(FIRST_MAKEFILE)
2590 ' if $self->{OBJECT};
2593 # We take a very conservative approach here, but it\'s worth it.
2594 # We move Makefile to Makefile.old here to avoid gnu make looping.
2595 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2596 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2597 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2598 -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2599 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2600 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2601 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2602 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2603 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2606 # To change behavior to :: would be nice, but would break Tk b9.02
2607 # so you find such a warning below the dist target.
2608 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2609 # }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2615 =item manifypods (o)
2617 Defines targets and routines to translate the pods into manpages and
2618 put them into the INST_* directories.
2623 my($self, %attribs) = @_;
2624 return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2625 %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2628 if (defined $self->{PERL_SRC}) {
2629 $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2631 $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2633 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2634 # Maybe a build by uninstalled Perl?
2635 $pod2man_exe = $self->catfile($self->{PERL_INC}, "pod", "pod2man");
2637 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2638 # No pod2man but some MAN3PODS to be installed
2641 Warning: I could not locate your pod2man program. Please make sure,
2642 your pod2man program is in your PATH before you execute 'make'
2645 $pod2man_exe = "-S pod2man";
2649 qq[POD2MAN_EXE = $pod2man_exe\n],
2650 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2651 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2652 $self->{MAKEFILE}, q[";' \\
2653 -e 'print "Manifying $$m{$$_}\n";' \\
2654 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2655 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2657 push @m, "\nmanifypods : pure_all ";
2658 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2661 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2662 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2663 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2670 Returns true, if the argument is likely to be a command.
2675 my($self,$file) = @_;
2676 return $file if -x $file && ! -d $file;
2680 =item maybe_command_in_dirs
2682 method under development. Not yet used. Ask Ilya :-)
2686 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2687 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2688 my($self, $names, $dirs, $trace, $ver) = @_;
2690 foreach $dir (@$dirs){
2691 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2692 foreach $name (@$names){
2694 if ($self->file_name_is_absolute($name)) { # /foo/bar
2696 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2697 $abs = $self->catfile($dir, $name);
2699 $abs = $self->catfile($self->curdir, $name);
2701 print "Checking $abs for $name\n" if ($trace >= 2);
2702 next unless $tryabs = $self->maybe_command($abs);
2703 print "Substituting $tryabs instead of $abs\n"
2704 if ($trace >= 2 and $tryabs ne $abs);
2707 print "Executing $abs\n" if ($trace >= 2);
2708 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2709 print "Using PERL=$abs\n" if $trace;
2712 } else { # Do not look for perl
2719 =item needs_linking (o)
2721 Does this module need linking? Looks into subdirectory objects (see
2722 also has_link_code())
2729 $caller = (caller(0))[3];
2730 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2731 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2732 if ($self->has_link_code or $self->{MAKEAPERL}){
2733 $self->{NEEDS_LINKING} = 1;
2736 foreach $child (keys %{$self->{CHILDREN}}) {
2737 if ($self->{CHILDREN}->{$child}->needs_linking) {
2738 $self->{NEEDS_LINKING} = 1;
2742 return $self->{NEEDS_LINKING} = 0;
2747 misnamed method (will have to be changed). The MM_Unix method just
2748 returns the argument without further processing.
2750 On VMS used to insure that colons marking targets are preceded by
2751 space - most Unix Makes don't need this, but it's necessary under VMS
2752 to distinguish the target delimiter from a colon appearing as part of
2758 my($self,$text) = @_;
2764 parse a file and return what you think is $VERSION in this file set to.
2765 It will return the string "undef" if it can't figure out what $VERSION
2771 my($self,$parsefile) = @_;
2775 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2778 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2781 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2782 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2784 package ExtUtils::MakeMaker::_version;
2793 $result = eval($eval);
2794 warn "Could not eval '$eval' in $parsefile: $@" if $@;
2795 $result = "undef" unless defined $result;
2802 =item parse_abstract
2804 parse a file and return what you think is the ABSTRACT
2808 sub parse_abstract {
2809 my($self,$parsefile) = @_;
2813 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2815 my $package = $self->{DISTNAME};
2816 $package =~ s/-/::/g;
2818 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2821 next unless /^($package\s-\s)(.*)/;
2831 Defines the string that is passed to recursive make calls in
2841 my($sep) = $Is_VMS ? ',' : '';
2844 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2845 push @pasthru, "$key=\"\$($key)\"";
2848 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2854 Takes no argument, returns the environment variable PATH as an array.
2860 my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2861 my $path = $ENV{PATH};
2862 $path =~ s:\\:/:g if $Is_OS2;
2863 my @path = split $path_sep, $path;
2864 foreach(@path) { $_ = '.' if $_ eq '' }
2870 Takes one argument, a file name, and returns the file name, if the
2871 argument is likely to be a perl script. On MM_Unix this is true for
2872 any ordinary, readable file.
2877 my($self,$file) = @_;
2878 return $file if -r $file && -f _;
2882 =item perldepend (o)
2884 Defines the dependency from all *.h files that come with the perl
2893 # Check for unpropogated config.sh changes. Should never happen.
2894 # We do NOT just update config.h because that is not sufficient.
2895 # An out of date config.h is not fatal but complains loudly!
2896 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2897 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2899 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2900 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2901 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2902 } if $self->{PERL_SRC};
2904 return join "", @m unless $self->needs_linking;
2908 $(PERL_INC)/EXTERN.h \
2909 $(PERL_INC)/INTERN.h \
2910 $(PERL_INC)/XSUB.h \
2912 $(PERL_INC)/cc_runtime.h \
2913 $(PERL_INC)/config.h \
2916 $(PERL_INC)/dosish.h \
2917 $(PERL_INC)/embed.h \
2918 $(PERL_INC)/embedvar.h \
2919 $(PERL_INC)/fakethr.h \
2920 $(PERL_INC)/form.h \
2922 $(PERL_INC)/handy.h \
2924 $(PERL_INC)/intrpvar.h \
2925 $(PERL_INC)/iperlsys.h \
2926 $(PERL_INC)/keywords.h \
2928 $(PERL_INC)/nostdio.h \
2929 $(PERL_INC)/objXSUB.h \
2931 $(PERL_INC)/opcode.h \
2932 $(PERL_INC)/opnames.h \
2933 $(PERL_INC)/patchlevel.h \
2934 $(PERL_INC)/perl.h \
2935 $(PERL_INC)/perlapi.h \
2936 $(PERL_INC)/perlio.h \
2937 $(PERL_INC)/perlsdio.h \
2938 $(PERL_INC)/perlsfio.h \
2939 $(PERL_INC)/perlvars.h \
2940 $(PERL_INC)/perly.h \
2942 $(PERL_INC)/pp_proto.h \
2943 $(PERL_INC)/proto.h \
2944 $(PERL_INC)/regcomp.h \
2945 $(PERL_INC)/regexp.h \
2946 $(PERL_INC)/regnodes.h \
2947 $(PERL_INC)/scope.h \
2949 $(PERL_INC)/thrdvar.h \
2950 $(PERL_INC)/thread.h \
2951 $(PERL_INC)/unixish.h \
2952 $(PERL_INC)/utf8.h \
2953 $(PERL_INC)/util.h \
2954 $(PERL_INC)/warnings.h
2956 $(OBJECT) : $(PERL_HDRS)
2957 } if $self->{OBJECT};
2959 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2966 Defines target that creates a PPD (Perl Package Description) file
2967 for a binary distribution.
2974 if ($self->{ABSTRACT_FROM}){
2975 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2976 Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2978 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2979 push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2981 push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2982 push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2983 my $abstract = $self->{ABSTRACT};
2984 $abstract =~ s/\n/\\n/sg;
2985 $abstract =~ s/</</g;
2986 $abstract =~ s/>/>/g;
2987 push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2988 my ($author) = $self->{AUTHOR};
2989 $author =~ s/</</g;
2990 $author =~ s/>/>/g;
2991 $author =~ s/@/\\@/g;
2992 push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2993 push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2995 foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2996 my $pre_req = $prereq;
2997 $pre_req =~ s/::/-/g;
2998 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), (0) x 4) [0 .. 3];
2999 push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" VERSION=\\\"$dep_ver\\\" />\\n}");
3001 push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
3002 push(@m, ". qq{\\t\\t<ARCHITECTURE NAME=\\\"$Config{'archname'}\\\" />\\n}");
3003 my ($bin_location) = $self->{BINARY_LOCATION};
3004 $bin_location =~ s/\\/\\\\/g;
3005 if ($self->{PPM_INSTALL_SCRIPT}) {
3006 if ($self->{PPM_INSTALL_EXEC}) {
3007 push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3010 push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3013 push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
3014 push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
3015 push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
3022 Returns the attribute C<PERM_RW> or the string C<644>.
3023 Used as the string that is passed
3024 to the C<chmod> command to set the permissions for read/writeable files.
3025 MakeMaker chooses C<644> because it has turned out in the past that
3026 relying on the umask provokes hard-to-track bug reports.
3027 When the return value is used by the perl function C<chmod>, it is
3028 interpreted as an octal value.
3033 shift->{PERM_RW} || "644";
3038 Returns the attribute C<PERM_RWX> or the string C<755>,
3039 i.e. the string that is passed
3040 to the C<chmod> command to set the permissions for executable files.
3046 shift->{PERM_RWX} || "755";
3051 Defines target that copies all files in the hash PM to their
3052 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3058 my($autodir) = $self->catdir('$(INST_LIB)','auto');
3060 pm_to_blib: $(TO_INST_PM)
3061 }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
3062 "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
3063 -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{','$(PM_FILTER)')"
3064 }.$self->{NOECHO}.q{$(TOUCH) $@
3068 =item post_constants (o)
3070 Returns an empty string per default. Dedicated to overrides from
3071 within Makefile.PL after all constants have been defined.
3080 =item post_initialize (o)
3082 Returns an empty string per default. Used in Makefile.PLs to add some
3083 chunk of text to the Makefile after the object is initialized.
3087 sub post_initialize {
3094 Returns an empty string. Can be used in Makefile.PLs to write some
3095 text to the Makefile at the end.
3106 Check a path variable in $self from %Config, if it contains a prefix,
3107 and replace it with another one.
3109 Takes as arguments an attribute name, a search prefix and a
3110 replacement prefix. Changes the attribute in the object.
3115 my($self,$var,$sprefix,$rprefix) = @_;
3116 $self->{uc $var} ||= $Config{lc $var};
3117 $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
3118 $self->{uc $var} =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s;
3123 Defines targets to run *.PL files.
3129 return "" unless $self->{PL_FILES};
3131 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3132 my $list = ref($self->{PL_FILES}->{$plfile})
3133 ? $self->{PL_FILES}->{$plfile}
3134 : [$self->{PL_FILES}->{$plfile}];
3136 foreach $target (@$list) {
3139 $self->{NOECHO}\$(NOOP)
3142 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile $target
3151 Defines the realclean target.
3156 my($self, %attribs) = @_;
3159 # Delete temporary files (via clean) and also delete installed files
3160 realclean purge :: clean
3162 # realclean subdirectories first (already cleaned)
3163 my $sub = ($Is_Win32 && Win32::IsWin95()) ?
3164 "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3165 "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3166 foreach(@{$self->{DIR}}){
3167 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3168 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3170 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3171 if( $self->has_link_code ){
3172 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3173 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
3175 # Issue a several little RM_F commands rather than risk creating a
3176 # very long command line (useful for extensions such as Encode
3177 # that have many files).
3178 if (keys %{$self->{PM}}) {
3180 foreach (values %{$self->{PM}}) {
3181 if (length($line) + length($_) > 80) {
3182 push @m, "\t$self->{RM_F} $line\n";
3189 push @m, "\t$self->{RM_F} $line\n" if $line;
3191 my(@otherfiles) = ($self->{MAKEFILE},
3192 "$self->{MAKEFILE}.old"); # Makefiles last
3193 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3194 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
3195 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
3199 =item replace_manpage_separator
3201 Takes the name of a package, which may be a nested package, in the
3202 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3206 sub replace_manpage_separator {
3207 my($self,$man) = @_;
3208 if ($^O eq 'uwin') {
3220 Defines the static target.
3225 # --- Static Loading Sections ---
3229 ## $(INST_PM) has been moved to the all: target.
3230 ## It remains here for awhile to allow for old usage: "make static"
3231 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3232 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3233 '.$self->{NOECHO}.'$(NOOP)
3237 =item static_lib (o)
3239 Defines how to produce the *.a (or equivalent) files.
3245 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3246 # return '' unless $self->needs_linking(); #might be because of a subdir
3248 return '' unless $self->has_link_code;
3252 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3255 # If this extension has it's own library (eg SDBM_File)
3256 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3257 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3260 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3261 # Prefer the absolute pathed ar if available so that PATH
3262 # doesn't confuse us. Perl itself is built with the full_ar.
3268 "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3270 q{ $(CHMOD) $(PERM_RWX) $@
3271 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3273 # Old mechanism - still available:
3275 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3276 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
3279 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3283 =item staticmake (o)
3290 my($self, %attribs) = @_;
3293 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3295 # And as it's not yet built, we add the current extension
3296 # but only if it has some C code (or XS code, which implies C code)
3297 if (@{$self->{C}}) {
3298 @static = $self->catfile($self->{INST_ARCHLIB},
3301 "$self->{BASEEXT}$self->{LIB_EXT}"
3305 # Either we determine now, which libraries we will produce in the
3306 # subdirectories or we do it at runtime of the make.
3308 # We could ask all subdir objects, but I cannot imagine, why it
3309 # would be necessary.
3311 # Instead we determine all libraries for the new perl at
3313 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3315 $self->makeaperl(MAKE => $self->{MAKEFILE},
3316 DIRS => \@searchdirs,
3319 TARGET => $self->{MAP_TARGET},
3321 LIBPERL => $self->{LIBPERL_A}
3327 Helper subroutine for subdirs
3332 my($self, $subdir) = @_;
3334 if ($Is_Win32 && Win32::IsWin95()) {
3335 if ($Config{'make'} =~ /dmake/i) {
3341 \$(MAKE) all \$(PASTHRU)
3345 } elsif ($Config{'make'} =~ /nmake/i) {
3350 \$(MAKE) all \$(PASTHRU)
3358 $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3366 Defines targets to process subdirectories.
3371 # --- Sub-directory Sections ---
3374 # This method provides a mechanism to automatically deal with
3375 # subdirectories containing further Makefile.PL scripts.
3376 # It calls the subdir_x() method for each subdirectory.
3377 foreach $dir (@{$self->{DIR}}){
3378 push(@m, $self->subdir_x($dir));
3379 #### print "Including $dir subdirectory\n";
3383 # The default clean, realclean and test targets in this Makefile
3384 # have automatically been given entries for each subdir.
3388 push(@m, "\n# none")
3395 Defines the test targets.
3400 # --- Test and Installation Sections ---
3402 my($self, %attribs) = @_;
3403 my $tests = $attribs{TESTS};
3404 if (!$tests && -d 't') {
3405 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3407 # note: 'test.pl' name is also hardcoded in init_dirscan()
3411 TEST_TYPE=test_\$(LINKTYPE)
3416 testdb :: testdb_\$(LINKTYPE)
3418 test :: \$(TEST_TYPE)
3420 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3422 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3423 unless $tests or -f "test.pl" or @{$self->{DIR}};
3426 push(@m, "test_dynamic :: pure_all\n");
3427 push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3428 push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3431 push(@m, "testdb_dynamic :: pure_all\n");
3432 push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3435 # Occasionally we may face this degenerate target:
3436 push @m, "test_ : test_dynamic\n\n";
3438 if ($self->needs_linking()) {
3439 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3440 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3441 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3443 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3444 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3447 push @m, "test_static :: test_dynamic\n";
3448 push @m, "testdb_static :: testdb_dynamic\n";
3453 =item test_via_harness (o)
3455 Helper method to write the test targets
3459 sub test_via_harness {
3460 my($self, $perl, $tests) = @_;
3461 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3462 "\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";
3465 =item test_via_script (o)
3467 Other helper method for test.
3471 sub test_via_script {
3472 my($self, $perl, $script) = @_;
3473 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3474 qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3478 =item tool_autosplit (o)
3480 Defines a simple perl call that runs autosplit. May be deprecated by
3485 sub tool_autosplit {
3486 # --- Tool Sections ---
3488 my($self, %attribs) = @_;
3490 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3492 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3493 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3497 =item tools_other (o)
3499 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3500 the Makefile. Also defines the perl programs MKPATH,
3501 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3508 my $bin_sh = $Config{sh} || '/bin/sh';
3513 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3514 push @m, "$_ = $self->{$_}\n";
3518 # The following is a portable way to say mkdir -p
3519 # To see which directories are created, change the if 0 to if 1
3520 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3522 # This helps us to minimize the effect of the .exists files A yet
3523 # better solution would be to have a stable file in the perl
3524 # distribution with a timestamp of zero. But this solution doesn't
3525 # need any changes to the core distribution and works with older perls
3526 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3530 return join "", @m if $self->{PARENT};
3533 # Here we warn users that an old packlist file was found somewhere,
3534 # and that they should call some uninstall routine
3535 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3536 -e 'print "WARNING: I have found an old package in\n";' \\
3537 -e 'print "\t$$ARGV[0].\n";' \\
3538 -e 'print "Please make sure the two installations are not conflicting\n";'
3543 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3544 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3546 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3547 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3548 -e 'print "=over 4";' \
3549 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3552 UNINSTALL = $(PERL) -MExtUtils::Install \
3553 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3554 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3555 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3561 =item tool_xsubpp (o)
3563 Determines typemaps, xsubpp version, prototype behaviour.
3569 return "" unless $self->needs_linking;
3570 my($xsdir) = $self->catdir($self->{PERL_LIB},"ExtUtils");
3571 my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3572 if( $self->{TYPEMAPS} ){
3574 foreach $typemap (@{$self->{TYPEMAPS}}){
3575 if( ! -f $typemap ){
3576 warn "Typemap $typemap not found.\n";
3579 push(@tmdeps, $typemap);
3583 push(@tmdeps, "typemap") if -f "typemap";
3584 my(@tmargs) = map("-typemap $_", @tmdeps);
3585 if( exists $self->{XSOPT} ){
3586 unshift( @tmargs, $self->{XSOPT} );
3590 my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3592 # What are the correct thresholds for version 1 && 2 Paul?
3593 if ( $xsubpp_version > 1.923 ){
3594 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3596 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3597 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3598 Your version of xsubpp is $xsubpp_version and cannot handle this.
3599 Please upgrade to a more recent version of xsubpp.
3602 $self->{XSPROTOARG} = "";
3606 my $xsubpp = "xsubpp";
3610 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3611 XSPROTOARG = $self->{XSPROTOARG}
3612 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3613 XSUBPPARGS = @tmargs
3619 my($self,$xsubpp) = @_;
3620 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3624 # try to figure out the version number of the xsubpp on the system
3626 # first try the -v flag, introduced in 1.921 & 2.000a2
3628 return "" unless $self->needs_linking;
3630 my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3631 print "Running $command\n" if $Verbose >= 2;
3632 $version = `$command` ;
3633 warn "Running '$command' exits with status " . ($?>>8) if $?;
3636 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3638 # nope, then try something else
3640 my $counter = '000';
3641 my ($file) = 'temp' ;
3642 $counter++ while -e "$file$counter"; # don't overwrite anything
3645 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3647 MODULE = fred PACKAGE = fred
3656 $command = "$self->{PERL} $xsubpp $file 2>&1";
3657 print "Running $command\n" if $Verbose >= 2;
3658 my $text = `$command` ;
3659 warn "Running '$command' exits with status " . ($?>>8) if $?;
3662 # gets 1.2 -> 1.92 and 2.000a1
3663 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3665 # it is either 1.0 or 1.1
3666 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3668 # none of the above, so 1.0
3669 return $Xsubpp_Version = "1.0" ;
3672 =item top_targets (o)
3674 Defines the targets all, subdirs, config, and O_FILES
3679 # --- Target Sections ---
3684 #all :: config $(INST_PM) subdirs linkext manifypods
3688 all :: pure_all htmlifypods manifypods
3689 '.$self->{NOECHO}.'$(NOOP)
3691 unless $self->{SKIPHASH}{'all'};
3694 pure_all :: config pm_to_blib subdirs linkext
3695 '.$self->{NOECHO}.'$(NOOP)
3697 subdirs :: $(MYEXTLIB)
3698 '.$self->{NOECHO}.'$(NOOP)
3700 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3701 '.$self->{NOECHO}.'$(NOOP)
3703 config :: $(INST_ARCHAUTODIR)/.exists
3704 '.$self->{NOECHO}.'$(NOOP)
3706 config :: $(INST_AUTODIR)/.exists
3707 '.$self->{NOECHO}.'$(NOOP)
3710 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3712 if (%{$self->{HTMLLIBPODS}}) {
3714 config :: \$(INST_HTMLLIBDIR)/.exists
3715 $self->{NOECHO}\$(NOOP)
3718 push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3721 if (%{$self->{HTMLSCRIPTPODS}}) {
3723 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3724 $self->{NOECHO}\$(NOOP)
3727 push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3730 if (%{$self->{MAN1PODS}}) {
3732 config :: \$(INST_MAN1DIR)/.exists
3733 $self->{NOECHO}\$(NOOP)
3736 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3738 if (%{$self->{MAN3PODS}}) {
3740 config :: \$(INST_MAN3DIR)/.exists
3741 $self->{NOECHO}\$(NOOP)
3744 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3748 $(O_FILES): $(H_FILES)
3749 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3753 perldoc ExtUtils::MakeMaker
3758 }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3759 -MExtUtils::MakeMaker=Version_check \
3760 -e "Version_check('$(MM_VERSION)')"
3768 Obsolete, deprecated method. Not used since Version 5.21.
3773 # --- perllocal.pod section ---
3774 my($self,$what,$name,@attribs)=@_;
3775 my $time = localtime;
3776 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3777 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3778 print "\n\n=back\n\n";
3783 Defines the suffix rules to compile XS files to C.
3789 return '' unless $self->needs_linking();
3792 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3798 Defines the suffix rules to compile XS files to C++.
3804 return '' unless $self->needs_linking();
3807 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3813 Defines suffix rules to go from XS to object files directly. This is
3814 only intended for broken make implementations.
3818 sub xs_o { # many makes are too dumb to use xs_c then c_o
3820 return '' unless $self->needs_linking();
3823 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3824 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3830 This is internal method that returns path to libperl.a equivalent
3831 to be linked to dynamic extensions. UNIX does not have one but OS2
3838 return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3842 =item perl_archive_after
3844 This is an internal method that returns path to a library which
3845 should be put on the linker command line I<after> the external libraries
3846 to be linked to dynamic extensions. This may be needed if the linker
3847 is one-pass, and Perl includes some overrides for C RTL functions,
3852 sub perl_archive_after
3859 This is internal method that returns name of a file that is
3860 passed to linker to define symbols to be exported.
3861 UNIX does not have one but OS2 and Win32 do.
3877 L<ExtUtils::MakeMaker>