1 package ExtUtils::MM_Unix;
3 require 5.005_03; # Maybe further back, dunno
9 use Config qw(%Config);
10 use File::Basename qw(basename dirname);
13 use vars qw($VERSION @ISA
14 $Is_Mac $Is_OS2 $Is_VMS $Is_Win32 $Is_Win95 $Is_Dos $Is_VOS
15 $Is_QNX $Is_AIX $Is_OSF $Is_IRIX $Is_NetBSD $Is_BSD
16 $Is_SunOS4 $Is_Solaris $Is_SunOS
21 use ExtUtils::MakeMaker qw($Verbose neatvalue);
25 require ExtUtils::MM_Any;
26 @ISA = qw(ExtUtils::MM_Any);
28 $Is_OS2 = $^O eq 'os2';
29 $Is_Mac = $^O eq 'MacOS';
30 $Is_Win32 = $^O eq 'MSWin32' || $Config{osname} eq 'NetWare';
31 $Is_Win95 = $Is_Win32 && Win32::IsWin95();
32 $Is_Dos = $^O eq 'dos';
33 $Is_VOS = $^O eq 'vos';
34 $Is_VMS = $^O eq 'VMS';
35 $Is_QNX = $^O eq 'qnx';
36 $Is_AIX = $^O eq 'aix';
37 $Is_OSF = $^O eq 'dec_osf';
38 $Is_IRIX = $^O eq 'irix';
39 $Is_NetBSD = $^O eq 'netbsd';
40 $Is_SunOS4 = $^O eq 'sunos';
41 $Is_Solaris = $^O eq 'solaris';
42 $Is_SunOS = $Is_SunOS4 || $Is_Solaris;
43 $Is_BSD = $^O =~ /^(?:free|net|open)bsd|bsdos$/;
48 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
52 C<require ExtUtils::MM_Unix;>
56 The methods provided by this package are designed to be used in
57 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
58 Makefile, it creates one or more objects that inherit their methods
59 from a package C<MM>. MM itself doesn't provide any methods, but it
60 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
61 specific packages take the responsibility for all the methods provided
62 by MM_Unix. We are trying to reduce the number of the necessary
63 overrides by defining rather primitive operations within
66 If you are going to write a platform specific MM package, please try
67 to limit the necessary overrides to primitive methods, and if it is not
68 possible to do so, let's work out how to achieve that gain.
70 If you are overriding any of these methods in your Makefile.PL (in the
71 MY class), please report that to the makemaker mailing list. We are
72 trying to minimize the necessary method overrides and switch to data
73 driven Makefile.PLs wherever possible. In the long run less methods
74 will be overridable via the MY class.
78 The following description of methods is still under
79 development. Please refer to the code for not suitably documented
80 sections and complain loudly to the makemaker@perl.org mailing list.
81 Better yet, provide a patch.
83 Not all of the methods below are overridable in a
84 Makefile.PL. Overridable methods are marked as (o). All methods are
85 overridable by a platform specific MM_*.pm file (See
86 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
90 # So we don't have to keep calling the methods over and over again,
91 # we have these globals to cache the values. Faster and shrtr.
92 my $Curdir = __PACKAGE__->curdir;
93 my $Rootdir = __PACKAGE__->rootdir;
94 my $Updir = __PACKAGE__->updir;
103 Simply says that we're Unix.
114 Defines the suffix rules to compile different flavors of C files to
120 # --- Translation Sections ---
123 return '' unless $self->needs_linking();
125 if (my $cpp = $Config{cpprun}) {
126 my $cpp_cmd = $self->const_cccmd;
127 $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/$cpp/;
130 '. $cpp_cmd . ' $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c > $*.i
135 $(CCCMD) -S $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
139 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
143 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.C
144 ' if !$Is_OS2 and !$Is_Win32 and !$Is_Dos; #Case-specific
147 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cpp
150 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cxx
153 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cc
160 Does very much the same as the cflags script in the perl
161 distribution. It doesn't return the whole compiler command line, but
162 initializes all of its parts. The const_cccmd method then actually
163 returns the definition of the CCCMD macro which uses these parts.
170 my($self,$libperl)=@_;
171 return $self->{CFLAGS} if $self->{CFLAGS};
172 return '' unless $self->needs_linking();
174 my($prog, $uc, $perltype, %cflags);
175 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
176 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
178 @cflags{qw(cc ccflags optimize shellflags)}
179 = @Config{qw(cc ccflags optimize shellflags)};
182 $cflags{shellflags} ||= '';
187 DE => '-DDEBUGGING -DEMBED',
188 M => '-DEMBED -DMULTIPLICITY',
189 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
192 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
195 $uc = ""; # avoid warning
197 $perltype = $map{$uc} ? $map{$uc} : "";
205 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
206 if ($prog = $Config{$name}) {
207 # Expand hints for this extension via the shell
208 print STDOUT "Processing $name hint:\n" if $Verbose;
209 my(@o)=`cc=\"$cflags{cc}\"
210 ccflags=\"$cflags{ccflags}\"
211 optimize=\"$cflags{optimize}\"
212 perltype=\"$cflags{perltype}\"
213 optdebug=\"$cflags{optdebug}\"
216 echo ccflags=\$ccflags
217 echo optimize=\$optimize
218 echo perltype=\$perltype
219 echo optdebug=\$optdebug
224 if ($line =~ /(.*?)=\s*(.*)\s*$/){
226 print STDOUT " $1 = $2\n" if $Verbose;
228 print STDOUT "Unrecognised result from hint: '$line'\n";
234 $cflags{optimize} = $optdebug;
237 for (qw(ccflags optimize perltype)) {
239 $cflags{$_} =~ s/^\s+//;
240 $cflags{$_} =~ s/\s+/ /g;
241 $cflags{$_} =~ s/\s+$//;
242 $self->{uc $_} ||= $cflags{$_};
245 if ($self->{POLLUTE}) {
246 $self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
250 if ($Config{usemymalloc} and not $Config{bincompat5005}
251 and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
252 and $self->{PERL_MALLOC_OK}) {
253 $pollute = '$(PERL_MALLOC_DEF)';
256 $self->{CCFLAGS} = quote_paren($self->{CCFLAGS});
257 $self->{OPTIMIZE} = quote_paren($self->{OPTIMIZE});
259 return $self->{CFLAGS} = qq{
260 CCFLAGS = $self->{CCFLAGS}
261 OPTIMIZE = $self->{OPTIMIZE}
262 PERLTYPE = $self->{PERLTYPE}
270 Defines the clean target.
275 # --- Cleanup and Distribution Sections ---
277 my($self, %attribs) = @_;
280 # Delete temporary files but do not touch installed files. We don\'t delete
281 # the Makefile here so a later make realclean still has a makefile to use.
283 clean :: clean_subdirs
286 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
288 my @errfiles = @{$self->{C}};
292 push( @otherfiles, @errfiles, 'perlmain.err' );
294 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
295 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE)
296 $(INST_ARCHAUTODIR)/extralibs.all
297 $(INST_ARCHAUTODIR)/extralibs.ld
298 perlmain.c tmon.out mon.out so_locations
300 *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
301 $(BOOTSTRAP) $(BASEEXT).bso
302 $(BASEEXT).def lib$(BASEEXT).def
303 $(BASEEXT).exp $(BASEEXT).x
306 push(@otherfiles, qw[*.kp]);
309 push(@otherfiles, qw[core core.*perl.*.? *perl.core]);
312 push(@otherfiles, map { "core." . "[0-9]"x$_ } (1..5));
315 push @m, "\t-\$(RM_RF) @otherfiles\n";
316 # See realclean and ext/utils/make_ext for usage of Makefile.old
318 "\t-\$(MV) \$(FIRST_MAKEFILE) \$(MAKEFILE_OLD) \$(DEV_NULL)\n");
320 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
325 =item clean_subdirs_target
327 my $make_frag = $MM->clean_subdirs_target;
329 Returns the clean_subdirs target. This is used by the clean target to
330 call clean on any subdirectories which contain Makefiles.
334 sub clean_subdirs_target {
337 # No subdirectories, no cleaning.
338 return <<'NOOP_FRAG' unless @{$self->{DIR}};
344 my $clean = "clean_subdirs :\n";
346 for my $dir (@{$self->{DIR}}) {
347 $clean .= sprintf <<'MAKE_FRAG', $dir;
348 -cd %s && $(TEST_F) $(FIRST_MAKEFILE) && $(MAKE) clean
356 =item const_cccmd (o)
358 Returns the full compiler call for C programs and stores the
359 definition in CONST_CCCMD.
364 my($self,$libperl)=@_;
365 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
366 return '' unless $self->needs_linking();
367 return $self->{CONST_CCCMD} =
368 q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
369 $(CCFLAGS) $(OPTIMIZE) \\
370 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
371 $(XS_DEFINE_VERSION)};
374 =item const_config (o)
376 Defines a couple of constants in the Makefile that are imported from
382 # --- Constants Sections ---
386 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
387 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
389 foreach $m (@{$self->{CONFIG}}){
390 # SITE*EXP macros are defined in &constants; avoid duplicates here
391 next if $once_only{$m};
392 $self->{uc $m} = quote_paren($self->{uc $m});
393 push @m, uc($m) , ' = ' , $self->{uc $m}, "\n";
399 =item const_loadlibs (o)
401 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
402 L<ExtUtils::Liblist> for details.
408 return "" unless $self->needs_linking;
411 # $self->{NAME} might depend on some other libraries:
412 # See ExtUtils::Liblist for details
417 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
419 next unless defined $self->{$tmp};
420 push @m, "$tmp = $self->{$tmp}\n";
427 my $make_frag = $mm->constants;
429 Prints out macros for lots of constants.
439 AR_STATIC_ARGS DIRFILESEP
441 VERSION VERSION_MACRO VERSION_SYM DEFINE_VERSION
442 XS_VERSION XS_VERSION_MACRO XS_DEFINE_VERSION
443 INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB
444 INST_MAN1DIR INST_MAN3DIR
448 PERLPREFIX SITEPREFIX VENDORPREFIX
450 (map { ("INSTALL".$_,
452 } $self->installvars),
457 FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE
458 PERLMAINCC PERL_SRC PERL_INC
459 PERL FULLPERL ABSPERL
460 PERLRUN FULLPERLRUN ABSPERLRUN
461 PERLRUNINST FULLPERLRUNINST ABSPERLRUNINST
467 next unless defined $self->{$macro};
469 # pathnames can have sharp signs in them; escape them so
470 # make doesn't think it is a comment-start character.
471 $self->{$macro} =~ s/#/\\#/g;
472 push @m, "$macro = $self->{$macro}\n";
476 MAKEMAKER = $self->{MAKEMAKER}
477 MM_VERSION = $self->{MM_VERSION}
478 MM_REVISION = $self->{MM_REVISION}
482 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
483 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
484 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
485 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
489 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
490 LDFROM LINKTYPE PM_FILTER
493 next unless defined $self->{$macro};
494 push @m, "$macro = $self->{$macro}\n";
498 # Handy lists of source code files:
499 XS_FILES = ".$self->wraplist(sort keys %{$self->{XS}})."
500 C_FILES = ".$self->wraplist(@{$self->{C}})."
501 O_FILES = ".$self->wraplist(@{$self->{O_FILES}})."
502 H_FILES = ".$self->wraplist(@{$self->{H}})."
503 MAN1PODS = ".$self->wraplist(sort keys %{$self->{MAN1PODS}})."
504 MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})."
509 # Where is the Config information that we are using/depend on
510 CONFIGDEP = $(PERL_ARCHLIB)$(DIRFILESEP)Config.pm $(PERL_INC)$(DIRFILESEP)config.h
515 # Where to build things
516 INST_LIBDIR = $self->{INST_LIBDIR}
517 INST_ARCHLIBDIR = $self->{INST_ARCHLIBDIR}
519 INST_AUTODIR = $self->{INST_AUTODIR}
520 INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR}
522 INST_STATIC = $self->{INST_STATIC}
523 INST_DYNAMIC = $self->{INST_DYNAMIC}
524 INST_BOOT = $self->{INST_BOOT}
530 EXPORT_LIST = $self->{EXPORT_LIST}
531 PERL_ARCHIVE = $self->{PERL_ARCHIVE}
532 PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER}
537 TO_INST_PM = ".$self->wraplist(sort keys %{$self->{PM}})."
539 PM_TO_BLIB = ".$self->wraplist(%{$self->{PM}})."
548 Same as macro for the depend attribute.
553 my($self,%attribs) = @_;
555 while (($key,$val) = each %attribs){
556 last unless defined $key;
557 push @m, "$key : $val\n";
563 =item dir_target B<DEPRECATED>
565 my $make_frag = $mm->dir_target(@directories);
567 I<This function is deprecated> its use is no longer necessary and is I<only
568 provided for backwards compatibility>. blibdirs_target provides a much
569 simpler mechanism and pm_to_blib() can create its own directories anyway.
571 Returns a Makefile entry for a .exists file in each of the @directories.
572 The purpose is to create a directory and provide a make target to depend on.
573 The make target is a .exists file in each of those directories.
577 $mm->dir_target('$(INST_ARCHDIR)');
579 would return the make target C<$(INST_ARCHDIR)/.exists> which would
580 create $(INST_ARCHDIR) and touch .exists. You would depend on this target
581 to make sure $(INST_ARCHDIR) is created.
583 Ignores directories which have already gone through dir_target() so you
584 might wind up getting nothing.
589 my($self, @dirs) = @_;
593 foreach my $dir (@dirs) {
594 my $targ = $self->catfile($dir, '.exists');
597 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
598 ($targdir = $targ) =~ s:/?\.exists\z::;
600 else { # while elsewhere we expect to see the dir separator in $targ
601 $targdir = dirname($targ);
604 next if $self->{DIR_TARGET}{$self}{$targdir}++;
607 $make .= <<MAKE_FRAG;
609 \$(NOECHO) \$(MKPATH) $targdir
610 \$(NOECHO) \$(TOUCH) $targ
611 \$(NOECHO) \$(CHMOD) \$(PERM_RWX) $targdir
617 # So these new .exists targets get called along with blibdirs.
618 my $blib_addition = '';
619 $blib_addition = <<MAKE_FRAG if @targs;
625 return $blib_addition . $make;
633 Defines the DESTDIR and DEST* variables paralleling the INSTALL*.
641 $self->{DESTDIR} ||= '';
643 # Make DEST variables.
644 foreach my $var ($self->installvars) {
645 my $destvar = 'DESTINSTALL'.$var;
646 $self->{$destvar} ||= '$(DESTDIR)$(INSTALL'.$var.')';
655 Defines a lot of macros for distribution support.
657 macro description default
659 TAR tar command to use tar
660 TARFLAGS flags to pass to TAR cvf
662 ZIP zip command to use zip
663 ZIPFLAGS flags to pass to ZIP -r
665 COMPRESS compression command to gzip --best
667 SUFFIX suffix to put on .gz
670 SHAR shar command to use shar
672 PREOP extra commands to run before
674 POSTOP extra commands to run after
677 TO_UNIX a command to convert linefeeds
678 to Unix style in your archive
680 CI command to checkin your ci -u
681 sources to version control
682 RCS_LABEL command to label your sources rcs -Nv$(VERSION_SYM): -q
685 DIST_CP $how argument to manicopy() best
686 when the distdir is created
688 DIST_DEFAULT default target to use to tardist
689 create a distribution
691 DISTVNAME name of the resulting archive $(DISTNAME)-$(VERSION)
699 $self->{TAR} ||= 'tar';
700 $self->{TARFLAGS} ||= 'cvf';
701 $self->{ZIP} ||= 'zip';
702 $self->{ZIPFLAGS} ||= '-r';
703 $self->{COMPRESS} ||= 'gzip --best';
704 $self->{SUFFIX} ||= '.gz';
705 $self->{SHAR} ||= 'shar';
706 $self->{PREOP} ||= '$(NOECHO) $(NOOP)'; # eg update MANIFEST
707 $self->{POSTOP} ||= '$(NOECHO) $(NOOP)'; # eg remove the distdir
708 $self->{TO_UNIX} ||= '$(NOECHO) $(NOOP)';
710 $self->{CI} ||= 'ci -u';
711 $self->{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q';
712 $self->{DIST_CP} ||= 'best';
713 $self->{DIST_DEFAULT} ||= 'tardist';
715 ($self->{DISTNAME} = $self->{NAME}) =~ s{::}{-}g unless $self->{DISTNAME};
716 $self->{DISTVNAME} ||= $self->{DISTNAME}.'-'.$self->{VERSION};
722 my $dist_macros = $mm->dist(%overrides);
724 Generates a make fragment defining all the macros initialized in
727 %overrides can be used to override any of the above.
732 my($self, %attribs) = @_;
736 TAR TARFLAGS ZIP ZIPFLAGS COMPRESS SUFFIX SHAR
738 CI RCS_LABEL DIST_CP DIST_DEFAULT
742 my $value = $attribs{$key} || $self->{$key};
743 $make .= "$key = $value\n";
749 =item dist_basics (o)
751 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
758 return <<'MAKE_FRAG';
759 distclean :: realclean distcheck
763 $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
766 $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
769 $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
771 veryclean : realclean
772 $(RM_F) *~ *.orig */*~ */*.orig
780 Defines a check in target for RCS.
788 $(PERLRUN) "-MExtUtils::Manifest=maniread" \\
789 -e "@all = keys %{ maniread() };" \\
790 -e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \\
791 -e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});"
797 my $dist_make_fragment = $MM->dist_core;
799 Puts the targets necessary for 'make dist' together into one make
808 foreach my $target (qw(dist tardist uutardist tarfile zipdist zipfile
811 my $method = $target.'_target';
813 $make_frag .= $self->$method();
822 my $make_frag = $MM->dist_target;
824 Returns the 'dist' target to make an archive for distribution. This
825 target simply checks to make sure the Makefile is up-to-date and
826 depends on $(DIST_DEFAULT).
833 my $date_check = $self->oneliner(<<'CODE', ['-l']);
834 print 'Warning: Makefile possibly out of date with $(VERSION_FROM)'
835 if -e '$(VERSION_FROM)' and -M '$(VERSION_FROM)' < -M '$(FIRST_MAKEFILE)';
838 return sprintf <<'MAKE_FRAG', $date_check;
839 dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
844 =item B<tardist_target>
846 my $make_frag = $MM->tardist_target;
848 Returns the 'tardist' target which is simply so 'make tardist' works.
849 The real work is done by the dynamically named tardistfile_target()
850 method, tardist should have that as a dependency.
857 return <<'MAKE_FRAG';
858 tardist : $(DISTVNAME).tar$(SUFFIX)
863 =item B<zipdist_target>
865 my $make_frag = $MM->zipdist_target;
867 Returns the 'zipdist' target which is simply so 'make zipdist' works.
868 The real work is done by the dynamically named zipdistfile_target()
869 method, zipdist should have that as a dependency.
876 return <<'MAKE_FRAG';
877 zipdist : $(DISTVNAME).zip
882 =item B<tarfile_target>
884 my $make_frag = $MM->tarfile_target;
886 The name of this target is the name of the tarball generated by
887 tardist. This target does the actual work of turning the distdir into
895 return <<'MAKE_FRAG';
896 $(DISTVNAME).tar$(SUFFIX) : distdir
899 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
900 $(RM_RF) $(DISTVNAME)
901 $(COMPRESS) $(DISTVNAME).tar
908 my $make_frag = $MM->zipfile_target;
910 The name of this target is the name of the zip file generated by
911 zipdist. This target does the actual work of turning the distdir into
919 return <<'MAKE_FRAG';
920 $(DISTVNAME).zip : distdir
922 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
923 $(RM_RF) $(DISTVNAME)
928 =item uutardist_target
930 my $make_frag = $MM->uutardist_target;
932 Converts the tarfile into a uuencoded file
936 sub uutardist_target {
939 return <<'MAKE_FRAG';
940 uutardist : $(DISTVNAME).tar$(SUFFIX)
941 uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu
948 my $make_frag = $MM->shdist_target;
950 Converts the distdir into a shell archive.
957 return <<'MAKE_FRAG';
960 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
961 $(RM_RF) $(DISTVNAME)
968 Defines the scratch directory target that will hold the distribution
969 before tar-ing (or shar-ing).
973 # For backwards compatibility.
974 *dist_dir = *distdir;
979 return <<'MAKE_FRAG';
980 distdir : metafile metafile_addtomanifest signature
981 $(RM_RF) $(DISTVNAME)
982 $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
983 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
991 Defines a target that produces the distribution in the
992 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
1002 cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
1003 cd $(DISTVNAME) && $(MAKE) $(PASTHRU)
1004 cd $(DISTVNAME) && $(MAKE) test $(PASTHRU)
1011 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
1017 my($self,%attribs) = @_;
1019 return '' unless ($Is_AIX && $self->needs_linking() );
1021 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
1022 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
1023 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
1027 dynamic :: $self->{BASEEXT}.exp
1029 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
1032 static :: $self->{BASEEXT}.exp
1034 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
1037 $self->{BASEEXT}.exp: Makefile.PL
1038 ",' $(PERLRUN) -e \'use ExtUtils::Mksymlists; \\
1039 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
1040 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
1041 ', "DL_VARS" => ', neatvalue($vars), ');\'
1049 Defines the dynamic target.
1054 # --- Dynamic Loading Sections ---
1058 dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
1063 =item dynamic_bs (o)
1065 Defines targets for bootstrap files.
1070 my($self, %attribs) = @_;
1073 ' unless $self->has_link_code();
1075 return <<'MAKE_FRAG';
1076 BOOTSTRAP = $(BASEEXT).bs
1078 # As Mkbootstrap might not write a file (if none is required)
1079 # we use touch to prevent make continually trying to remake it.
1080 # The DynaLoader only reads a non-empty file.
1081 $(BOOTSTRAP): $(FIRST_MAKEFILE) $(BOOTDEP) blibdirs
1082 $(NOECHO) $(ECHO) "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1083 $(NOECHO) $(PERLRUN) \
1084 "-MExtUtils::Mkbootstrap" \
1085 -e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');"
1086 $(NOECHO) $(TOUCH) $(BOOTSTRAP)
1087 $(CHMOD) $(PERM_RW) $@
1089 $(INST_BOOT): $(BOOTSTRAP) blibdirs
1090 $(NOECHO) $(RM_RF) $(INST_BOOT)
1091 -$(CP) $(BOOTSTRAP) $(INST_BOOT)
1092 $(CHMOD) $(PERM_RW) $@
1096 =item dynamic_lib (o)
1098 Defines how to produce the *.so (or equivalent) files.
1103 my($self, %attribs) = @_;
1104 return '' unless $self->needs_linking(); #might be because of a subdir
1106 return '' unless $self->has_link_code;
1108 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1109 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1110 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1111 my($ldfrom) = '$(LDFROM)';
1112 $armaybe = 'ar' if ($Is_OSF and $armaybe eq ':');
1114 my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
1115 my $ld_fix = $Is_OS2 ? '|| ( $(RM_F) $@ && sh -c false )' : '';
1117 # This section creates the dynamically loadable $(INST_DYNAMIC)
1118 # from $(OBJECT) and possibly $(MYEXTLIB).
1119 ARMAYBE = '.$armaybe.'
1120 OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
1121 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1122 INST_DYNAMIC_FIX = '.$ld_fix.'
1124 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) blibdirs $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
1126 if ($armaybe ne ':'){
1127 $ldfrom = 'tmp$(LIB_EXT)';
1128 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1129 push(@m,' $(RANLIB) '."$ldfrom\n");
1131 $ldfrom = "-all $ldfrom -none" if $Is_OSF;
1133 # The IRIX linker doesn't use LD_RUN_PATH
1134 my $ldrun = $Is_IRIX && $self->{LD_RUN_PATH} ?
1135 qq{-rpath "$self->{LD_RUN_PATH}"} : '';
1137 # For example in AIX the shared objects/libraries from previous builds
1138 # linger quite a while in the shared dynalinker cache even when nobody
1139 # is using them. This is painful if one for instance tries to restart
1140 # a failed build because the link command will fail unnecessarily 'cos
1141 # the shared object/library is 'busy'.
1142 push(@m,' $(RM_F) $@
1145 my $libs = '$(LDLOADLIBS)';
1147 if ($Is_NetBSD && $Config{'useshrplib'}) {
1148 # Use nothing on static perl platforms, and to the flags needed
1149 # to link against the shared libperl library on shared perl
1150 # platforms. We peek at lddlflags to see if we need -Wl,-R
1151 # or -R to add paths to the run-time library search path.
1152 if ($Config{'lddlflags'} =~ /-Wl,-R/) {
1153 $libs .= ' -L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -Wl,-R$(PERL_ARCHLIB)/CORE -lperl';
1154 } elsif ($Config{'lddlflags'} =~ /-R/) {
1155 $libs .= ' -L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -R$(PERL_ARCHLIB)/CORE -lperl';
1160 ' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1161 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) '.$libs.' $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST) $(INST_DYNAMIC_FIX)');
1163 $(CHMOD) $(PERM_RWX) $@
1171 Deprecated method. Use libscan instead.
1176 my($self,$path) = @_;
1182 Called by init_others, and calls ext ExtUtils::Liblist. See
1183 L<ExtUtils::Liblist> for details.
1188 my($self,$libs) = @_;
1189 require ExtUtils::Liblist;
1190 $self->ext($libs, $Verbose);
1195 Finds the executables PERL and FULLPERL
1200 my($self, $ver, $names, $dirs, $trace) = @_;
1203 print "Looking for perl $ver by these names:
1210 my $stderr_duped = 0;
1213 if( open(STDERR_COPY, '>&STDERR') ) {
1218 find_perl() can't dup STDERR: $!
1219 You might see some garbage while we search for Perl
1224 foreach $name (@$names){
1225 foreach $dir (@$dirs){
1226 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1228 if ($self->file_name_is_absolute($name)) { # /foo/bar
1230 } elsif ($self->canonpath($name) eq
1231 $self->canonpath(basename($name))) { # foo
1232 $abs = $self->catfile($dir, $name);
1234 $abs = $self->catfile($Curdir, $name);
1236 print "Checking $abs\n" if ($trace >= 2);
1237 next unless $self->maybe_command($abs);
1238 print "Executing $abs\n" if ($trace >= 2);
1240 my $version_check = qq{$abs -le "require $ver; print qq{VER_OK}"};
1241 # To avoid using the unportable 2>&1 to supress STDERR,
1242 # we close it before running the command.
1243 # However, thanks to a thread library bug in many BSDs
1244 # ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 )
1245 # we cannot use the fancier more portable way in here
1246 # but instead need to use the traditional 2>&1 construct.
1248 $val = `$version_check 2>&1`;
1250 close STDERR if $stderr_duped;
1251 $val = `$version_check`;
1252 open STDERR, '>&STDERR_COPY' if $stderr_duped;
1255 if ($val =~ /^VER_OK/) {
1256 print "Using PERL=$abs\n" if $trace;
1258 } elsif ($trace >= 2) {
1259 print "Result: '$val'\n";
1263 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1264 0; # false and not empty
1269 my $test = $mm->find_tests;
1271 Returns a string suitable for feeding to the shell to return all
1283 =head2 Methods to actually produce chunks of text for the Makefile
1285 The methods here are called for each MakeMaker object in the order
1286 specified by @ExtUtils::MakeMaker::MM_Sections.
1294 Inserts the sharpbang or equivalent magic number to a set of @files.
1298 sub fixin { # stolen from the pink Camel book, more or less
1299 my($self, @files) = @_;
1301 my($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
1302 for my $file (@files) {
1303 my $file_new = "$file.new";
1304 my $file_bak = "$file.bak";
1308 open(FIXIN, $file) or croak "Can't process '$file': $!";
1310 chomp(my $line = <FIXIN>);
1311 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1312 # Now figure out the interpreter name.
1313 my($cmd,$arg) = split ' ', $line, 2;
1316 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1318 if ($cmd eq "perl") {
1319 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1320 $interpreter = $Config{startperl};
1321 $interpreter =~ s,^\#!,,;
1323 $interpreter = $Config{perlpath};
1326 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1329 foreach $dir (@absdirs) {
1330 if ($self->maybe_command($cmd)) {
1331 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1332 $interpreter = $self->catfile($dir,$cmd);
1336 # Figure out how to invoke interpreter on this machine.
1340 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1341 # this is probably value-free on DOSISH platforms
1343 $shb .= "$Config{'sharpbang'}$interpreter";
1344 $shb .= ' ' . $arg if defined $arg;
1348 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1349 if 0; # not running under some shell
1350 } unless $Is_Win32; # this won't work on win32, so don't
1352 warn "Can't find $cmd in PATH, $file unchanged"
1357 unless ( open(FIXOUT,">$file_new") ) {
1358 warn "Can't create new $file: $!\n";
1362 # Print out the new #! line (or equivalent).
1365 print FIXOUT $shb, <FIXIN>;
1369 chmod 0666, $file_bak;
1371 unless ( rename($file, $file_bak) ) {
1372 warn "Can't rename $file to $file_bak: $!";
1375 unless ( rename($file_new, $file) ) {
1376 warn "Can't rename $file_new to $file: $!";
1377 unless ( rename($file_bak, $file) ) {
1378 warn "Can't rename $file_bak back to $file either: $!";
1379 warn "Leaving $file renamed as $file_bak\n";
1385 close(FIXIN) if fileno(FIXIN);
1386 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1398 '# Phony target to force checking subdirectories.
1406 Guess the name of this package by examining the working directory's
1407 name. MakeMaker calls this only if the developer has not supplied a
1417 my $name = basename(cwd());
1418 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1419 # strip minus or underline
1420 # followed by a float or some such
1421 print "Warning: Guessing NAME [$name] from current directory name.\n";
1427 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1428 object that need a compiler. Does not descend into subdirectories as
1429 needs_linking() does.
1435 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1436 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1437 $self->{HAS_LINK_CODE} = 1;
1440 return $self->{HAS_LINK_CODE} = 0;
1446 Scans the directory structure and initializes DIR, XS, XS_FILES, PM,
1447 C, C_FILES, O_FILES, H, H_FILES, PL_FILES, MAN*PODS, EXE_FILES.
1449 Called by init_main.
1453 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1455 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1458 @ignore{qw(Makefile.PL test.pl t)} = (1,1,1);
1460 # ignore the distdir
1461 $Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1
1462 : $ignore{$self->{DISTVNAME}} = 1;
1464 @ignore{map lc, keys %ignore} = values %ignore if $Is_VMS;
1466 foreach $name ($self->lsdir($Curdir)){
1467 next if $name =~ /\#/;
1468 next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
1469 next unless $self->libscan($name);
1471 next if -l $name; # We do not support symlinks at all
1472 next if $self->{NORECURS};
1473 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1474 } elsif ($name =~ /\.xs\z/){
1475 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1478 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1480 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1481 } elsif ($name =~ /\.h\z/i){
1483 } elsif ($name =~ /\.PL\z/) {
1484 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1485 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1486 # case-insensitive filesystem, one dot per name, so foo.h.PL
1487 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1488 local($/); open(PL,$name); my $txt = <PL>; close PL;
1489 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1490 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1493 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1495 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1496 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1500 # Some larger extensions often wish to install a number of *.pm/pl
1501 # files into the library in various locations.
1503 # The attribute PMLIBDIRS holds an array reference which lists
1504 # subdirectories which we should search for library files to
1505 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1506 # recursively search through the named directories (skipping any
1507 # which don't exist or contain Makefile.PL files).
1509 # For each *.pm or *.pl file found $self->libscan() is called with
1510 # the default installation path in $_[1]. The return value of
1511 # libscan defines the actual installation location. The default
1512 # libscan function simply returns the path. The file is skipped
1513 # if libscan returns false.
1515 # The default installation location passed to libscan in $_[1] is:
1517 # ./*.pm => $(INST_LIBDIR)/*.pm
1518 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1519 # ./lib/... => $(INST_LIB)/...
1521 # In this way the 'lib' directory is seen as the root of the actual
1522 # perl library whereas the others are relative to INST_LIBDIR
1523 # (which includes PARENT_NAME). This is a subtle distinction but one
1524 # that's important for nested modules.
1526 unless( $self->{PMLIBDIRS} ) {
1528 # Avoid logical name vs directory collisions
1529 $self->{PMLIBDIRS} = ['./lib', "./$self->{BASEEXT}"];
1532 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}];
1536 #only existing directories that aren't in $dir are allowed
1538 # Avoid $_ wherever possible:
1539 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1540 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1542 @{$self->{PMLIBDIRS}} = ();
1543 foreach $pmlibdir (@pmlibdirs) {
1544 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1547 if (@{$self->{PMLIBDIRS}}){
1548 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1551 File::Find::find(sub {
1553 unless ($self->libscan($_)){
1554 $File::Find::prune = 1;
1559 return if /~$/; # emacs temp files
1560 return if /,v$/; # RCS files
1562 my $path = $File::Find::name;
1563 my $prefix = $self->{INST_LIBDIR};
1566 $prefix = $self->{INST_LIB}
1567 if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1569 my($inst) = $self->catfile($prefix,$striplibpath);
1570 local($_) = $inst; # for backwards compatibility
1571 $inst = $self->libscan($inst);
1572 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1573 return unless $inst;
1575 }, @{$self->{PMLIBDIRS}});
1578 $self->{PM} ||= \%pm;
1579 $self->{PL_FILES} ||= \%pl_files;
1581 $self->{DIR} ||= [sort keys %dir];
1583 $self->{XS} ||= \%xs;
1584 $self->{C} ||= [sort keys %c];
1585 my @o_files = @{$self->{C}};
1586 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files];
1588 $self->{H} ||= [sort keys %h];
1590 # Set up names of manual pages to generate from pods
1592 foreach my $man (qw(MAN1 MAN3)) {
1593 unless ($self->{"${man}PODS"}) {
1594 $self->{"${man}PODS"} = {};
1595 $pods{$man} = 1 unless
1596 $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/;
1601 if ( exists $self->{EXE_FILES} ) {
1602 foreach $name (@{$self->{EXE_FILES}}) {
1605 if (open(FH,"<$name")) {
1607 if (/^=(?:head\d+|item|pod)\b/) {
1614 # If it doesn't exist yet, we assume, it has pods in it
1619 $self->{MAN1PODS}->{$name} =
1620 $self->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1626 my %manifypods = (); # we collect the keys first, i.e. the files
1627 # we have to convert to pod
1628 foreach $name (keys %{$self->{PM}}) {
1629 if ($name =~ /\.pod\z/ ) {
1630 $manifypods{$name} = $self->{PM}{$name};
1631 } elsif ($name =~ /\.p[ml]\z/ ) {
1634 if (open(FH,"<$name")) {
1636 if (/^=head1\s+\w+/) {
1646 $manifypods{$name} = $self->{PM}{$name};
1651 # Remove "Configure.pm" and similar, if it's not the only pod listed
1652 # To force inclusion, just name it "Configure.pod", or override
1654 foreach $name (keys %manifypods) {
1655 if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) {
1656 delete $manifypods{$name};
1659 my($manpagename) = $name;
1660 $manpagename =~ s/\.p(od|m|l)\z//;
1661 # everything below lib is ok
1662 unless($manpagename =~ s!^\W*lib\W+!!s) {
1663 $manpagename = $self->catfile(
1664 split(/::/,$self->{PARENT_NAME}),$manpagename
1668 $manpagename = $self->replace_manpage_separator($manpagename);
1669 $self->{MAN3PODS}->{$name} =
1670 $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1676 =item init_DIRFILESEP
1678 Using / for Unix. Called by init_main.
1682 sub init_DIRFILESEP {
1685 $self->{DIRFILESEP} = '/';
1691 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1692 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1693 INSTALL*, INSTALLDIRS, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1694 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1695 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1696 VERSION_SYM, XS_VERSION.
1703 # --- Initialize Module Name and Paths
1705 # NAME = Foo::Bar::Oracle
1706 # FULLEXT = Foo/Bar/Oracle
1708 # PARENT_NAME = Foo::Bar
1710 ### ($self->{FULLEXT} =
1711 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1712 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1715 # Copied from DynaLoader:
1717 my(@modparts) = split(/::/,$self->{NAME});
1718 my($modfname) = $modparts[-1];
1720 # Some systems have restrictions on files names for DLL's etc.
1721 # mod2fname returns appropriate file base name (typically truncated)
1722 # It may also edit @modparts if required.
1723 if (defined &DynaLoader::mod2fname) {
1724 $modfname = &DynaLoader::mod2fname(\@modparts);
1727 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1728 $self->{PARENT_NAME} ||= '';
1730 if (defined &DynaLoader::mod2fname) {
1731 # As of 5.001m, dl_os2 appends '_'
1732 $self->{DLBASE} = $modfname;
1734 $self->{DLBASE} = '$(BASEEXT)';
1738 # --- Initialize PERL_LIB, PERL_SRC
1740 # *Real* information: where did we get these two from? ...
1741 my $inc_config_dir = dirname($INC{'Config.pm'});
1742 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1744 unless ($self->{PERL_SRC}){
1746 foreach $dir ($Updir,
1747 $self->catdir($Updir,$Updir),
1748 $self->catdir($Updir,$Updir,$Updir),
1749 $self->catdir($Updir,$Updir,$Updir,$Updir),
1750 $self->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1753 -f $self->catfile($dir,"config_h.SH")
1755 -f $self->catfile($dir,"perl.h")
1757 -f $self->catfile($dir,"lib","Exporter.pm")
1759 $self->{PERL_SRC}=$dir ;
1765 warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1766 $self->{PERL_CORE} and !$self->{PERL_SRC};
1768 if ($self->{PERL_SRC}){
1769 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1771 if (defined $Cross::platform) {
1772 $self->{PERL_ARCHLIB} =
1773 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform);
1775 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform,
1776 $Is_Win32?("CORE"):());
1779 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1780 $self->{PERL_INC} = ($Is_Win32) ?
1781 $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1784 # catch a situation that has occurred a few times in the past:
1786 -s $self->catfile($self->{PERL_SRC},'cflags')
1790 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1797 You cannot build extensions below the perl source tree after executing
1798 a 'make clean' in the perl source tree.
1800 To rebuild extensions distributed with the perl source you should
1801 simply Configure (to include those extensions) and then build perl as
1802 normal. After installing perl the source tree can be deleted. It is
1803 not needed for building extensions by running 'perl Makefile.PL'
1804 usually without extra arguments.
1806 It is recommended that you unpack and build additional extensions away
1807 from the perl source tree.
1811 # we should also consider $ENV{PERL5LIB} here
1812 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1813 $self->{PERL_LIB} ||= $Config{privlibexp};
1814 $self->{PERL_ARCHLIB} ||= $Config{archlibexp};
1815 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1818 if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
1820 # Maybe somebody tries to build an extension with an
1821 # uninstalled Perl outside of Perl build tree
1823 for my $dir (@INC) {
1824 $found = $dir, last if -e $self->catdir($dir, "Config.pm");
1827 my $inc = dirname $found;
1828 if (-e $self->catdir($inc, "perl.h")) {
1829 $self->{PERL_LIB} = $found;
1830 $self->{PERL_ARCHLIB} = $found;
1831 $self->{PERL_INC} = $inc;
1832 $self->{UNINSTALLED_PERL} = 1;
1834 ... Detected uninstalled Perl. Trying to continue.
1841 # We get SITELIBEXP and SITEARCHEXP directly via
1842 # Get_from_Config. When we are running standard modules, these
1843 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1844 # set it to "site". I prefer that INSTALLDIRS be set from outside
1846 $self->{INSTALLDIRS} ||= "site";
1848 $self->{MAN1EXT} ||= $Config{man1ext};
1849 $self->{MAN3EXT} ||= $Config{man3ext};
1851 # Get some stuff out of %Config if we haven't yet done so
1852 print STDOUT "CONFIG must be an array ref\n"
1853 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1854 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1855 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1856 push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1858 foreach my $m (@{$self->{CONFIG}}){
1859 next if $once_only{$m};
1860 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1861 unless exists $Config{$m};
1862 $self->{uc $m} ||= $Config{$m};
1866 # This is too dangerous:
1867 # if ($^O eq "next") {
1868 # $self->{AR} = "libtool";
1869 # $self->{AR_STATIC_ARGS} = "-o";
1871 # But I leave it as a placeholder
1873 $self->{AR_STATIC_ARGS} ||= "cr";
1875 # These should never be needed
1876 $self->{OBJ_EXT} ||= '.o';
1877 $self->{LIB_EXT} ||= '.a';
1879 $self->{MAP_TARGET} ||= "perl";
1881 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1883 # make a simple check if we find Exporter
1884 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1885 (Exporter.pm not found)"
1886 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1887 $self->{NAME} eq "ExtUtils::MakeMaker";
1892 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH, LD,
1893 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, SHELL, NOOP,
1894 FIRST_MAKEFILE, MAKEFILE_OLD, NOECHO, RM_F, RM_RF, TEST_F,
1895 TOUCH, CP, MV, CHMOD, UMASK_NULL, ECHO, ECHO_N
1899 sub init_others { # --- Initialize Other Attributes
1902 $self->{LD} ||= 'ld';
1904 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1905 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1906 # undefined. In any case we turn it into an anon array:
1908 # May check $Config{libs} too, thus not empty.
1909 $self->{LIBS} = [$self->{LIBS}] unless ref $self->{LIBS};
1911 $self->{LIBS} = [''] unless @{$self->{LIBS}} && defined $self->{LIBS}[0];
1912 $self->{LD_RUN_PATH} = "";
1914 foreach $libs ( @{$self->{LIBS}} ){
1915 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1916 my(@libs) = $self->extliblist($libs);
1917 if ($libs[0] or $libs[1] or $libs[2]){
1918 # LD_RUN_PATH now computed by ExtUtils::Liblist
1919 ($self->{EXTRALIBS}, $self->{BSLOADLIBS},
1920 $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1925 if ( $self->{OBJECT} ) {
1926 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1928 # init_dirscan should have found out, if we have C files
1929 $self->{OBJECT} = "";
1930 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1932 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1933 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1934 $self->{PERLMAINCC} ||= '$(CC)';
1935 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1937 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1938 # the 'dynamic' section of MM. We don't have this problem with
1939 # 'static', since we either must use it (%Config says we can't
1940 # use dynamic loading) or the caller asked for it explicitly.
1941 if (!$self->{LINKTYPE}) {
1942 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1944 : ($Config{usedl} ? 'dynamic' : 'static');
1947 $self->{NOOP} ||= '$(SHELL) -c true';
1948 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1950 $self->{FIRST_MAKEFILE} ||= 'Makefile';
1951 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1952 $self->{MAKEFILE_OLD} ||= $self->{MAKEFILE}.'.old';
1953 $self->{MAKE_APERL_FILE} ||= $self->{MAKEFILE}.'.aperl';
1955 $self->{SHELL} ||= $Config{sh} || '/bin/sh';
1957 $self->{ECHO} ||= 'echo';
1958 $self->{ECHO_N} ||= 'echo -n';
1959 $self->{RM_F} ||= "rm -f";
1960 $self->{RM_RF} ||= "rm -rf";
1961 $self->{TOUCH} ||= "touch";
1962 $self->{TEST_F} ||= "test -f";
1963 $self->{CP} ||= "cp";
1964 $self->{MV} ||= "mv";
1965 $self->{CHMOD} ||= "chmod";
1966 $self->{MKPATH} ||= '$(PERLRUN) "-MExtUtils::Command" -e mkpath';
1967 $self->{EQUALIZE_TIMESTAMP} ||=
1968 '$(PERLRUN) "-MExtUtils::Command" -e eqtime';
1970 $self->{UNINST} ||= 0;
1971 $self->{VERBINST} ||= 0;
1972 $self->{MOD_INSTALL} ||=
1973 $self->oneliner(<<'CODE', ['-MExtUtils::Install']);
1974 install({@ARGV}, '$(VERBINST)', 0, '$(UNINST)');
1976 $self->{DOC_INSTALL} ||=
1977 '$(PERLRUN) "-MExtUtils::Command::MM" -e perllocal_install';
1978 $self->{UNINSTALL} ||=
1979 '$(PERLRUN) "-MExtUtils::Command::MM" -e uninstall';
1980 $self->{WARN_IF_OLD_PACKLIST} ||=
1981 '$(PERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist';
1983 $self->{UMASK_NULL} ||= "umask 0";
1984 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1993 Called by init_main. Sets up all INST_* variables except those related
1994 to XS code. Those are handled in init_xs.
2001 $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
2002 $self->{INST_BIN} ||= $self->catdir($Curdir,'blib','bin');
2004 # INST_LIB typically pre-set if building an extension after
2005 # perl has been built and installed. Setting INST_LIB allows
2006 # you to build directly into, say $Config{privlibexp}.
2007 unless ($self->{INST_LIB}){
2008 if ($self->{PERL_CORE}) {
2009 if (defined $Cross::platform) {
2010 $self->{INST_LIB} = $self->{INST_ARCHLIB} =
2011 $self->catdir($self->{PERL_LIB},"..","xlib",
2015 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
2018 $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
2022 my @parentdir = split(/::/, $self->{PARENT_NAME});
2023 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)', @parentdir);
2024 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)', @parentdir);
2025 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)', 'auto',
2027 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
2030 $self->{INST_SCRIPT} ||= $self->catdir($Curdir,'blib','script');
2032 $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
2033 $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
2042 Called by init_main. Sets up all INSTALL_* variables (except
2043 INSTALLDIRS) and *PREFIX.
2050 $self->init_lib2arch;
2052 # There are often no Config.pm defaults for these new man variables so
2053 # we fall back to the old behavior which is to use installman*dir
2054 foreach my $num (1, 3) {
2055 my $k = 'installsiteman'.$num.'dir';
2057 $self->{uc $k} ||= uc "\$(installman${num}dir)"
2061 foreach my $num (1, 3) {
2062 my $k = 'installvendorman'.$num.'dir';
2064 unless( $Config{$k} ) {
2065 $self->{uc $k} ||= $Config{usevendorprefix}
2066 ? uc "\$(installman${num}dir)"
2071 $self->{INSTALLSITEBIN} ||= '$(INSTALLBIN)'
2072 unless $Config{installsitebin};
2074 unless( $Config{installvendorbin} ) {
2075 $self->{INSTALLVENDORBIN} ||= $Config{usevendorprefix}
2076 ? $Config{installbin}
2081 my $iprefix = $Config{installprefixexp} || $Config{installprefix} ||
2082 $Config{prefixexp} || $Config{prefix} || '';
2083 my $vprefix = $Config{usevendorprefix} ? $Config{vendorprefixexp} : '';
2084 my $sprefix = $Config{siteprefixexp} || '';
2086 # 5.005_03 doesn't have a siteprefix.
2087 $sprefix = $iprefix unless $sprefix;
2090 $self->{PREFIX} ||= '';
2092 if( $self->{PREFIX} ) {
2093 @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
2097 $self->{PERLPREFIX} ||= $iprefix;
2098 $self->{SITEPREFIX} ||= $sprefix;
2099 $self->{VENDORPREFIX} ||= $vprefix;
2101 # Lots of MM extension authors like to use $(PREFIX) so we
2102 # put something sensible in there no matter what.
2103 $self->{PREFIX} = '$('.uc $self->{INSTALLDIRS}.'PREFIX)';
2106 my $arch = $Config{archname};
2107 my $version = $Config{version};
2110 my $libstyle = $Config{installstyle} || 'lib/perl5';
2113 if( $self->{LIBSTYLE} ) {
2114 $libstyle = $self->{LIBSTYLE};
2115 $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
2118 # Some systems, like VOS, set installman*dir to '' if they can't
2120 for my $num (1, 3) {
2121 $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
2122 unless $Config{'installman'.$num.'dir'};
2127 bin => { s => $iprefix,
2130 vendorbin => { s => $vprefix,
2133 sitebin => { s => $sprefix,
2136 script => { s => $iprefix,
2143 man1dir => { s => $iprefix,
2146 style => $manstyle, },
2147 siteman1dir => { s => $sprefix,
2150 style => $manstyle, },
2151 vendorman1dir => { s => $vprefix,
2154 style => $manstyle, },
2156 man3dir => { s => $iprefix,
2159 style => $manstyle, },
2160 siteman3dir => { s => $sprefix,
2163 style => $manstyle, },
2164 vendorman3dir => { s => $vprefix,
2167 style => $manstyle, },
2172 privlib => { s => $iprefix,
2175 style => $libstyle, },
2176 vendorlib => { s => $vprefix,
2179 style => $libstyle, },
2180 sitelib => { s => $sprefix,
2183 style => $libstyle, },
2185 archlib => { s => $iprefix,
2187 d => "$version/$arch",
2188 style => $libstyle },
2189 vendorarch => { s => $vprefix,
2191 d => "$version/$arch",
2192 style => $libstyle },
2193 sitearch => { s => $sprefix,
2195 d => "site_perl/$version/$arch",
2196 style => $libstyle },
2200 # Special case for LIB.
2201 if( $self->{LIB} ) {
2202 foreach my $var (keys %lib_layouts) {
2203 my $Installvar = uc "install$var";
2205 if( $var =~ /arch/ ) {
2206 $self->{$Installvar} ||=
2207 $self->catdir($self->{LIB}, $Config{archname});
2210 $self->{$Installvar} ||= $self->{LIB};
2215 my %type2prefix = ( perl => 'PERLPREFIX',
2216 site => 'SITEPREFIX',
2217 vendor => 'VENDORPREFIX'
2220 my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
2221 while( my($var, $layout) = each(%layouts) ) {
2222 my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
2223 my $r = '$('.$type2prefix{$t}.')';
2225 print STDERR "Prefixing $var\n" if $Verbose >= 2;
2227 my $installvar = "install$var";
2228 my $Installvar = uc $installvar;
2229 next if $self->{$Installvar};
2231 $d = "$style/$d" if $style;
2232 $self->prefixify($installvar, $s, $r, $d);
2234 print STDERR " $Installvar == $self->{$Installvar}\n"
2238 # Generate these if they weren't figured out.
2239 $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
2240 $self->{VENDORLIBEXP} ||= $self->{INSTALLVENDORLIB};
2247 Unix has no need of special linker flags.
2253 $self->{PERL_ARCHIVE} ||= '';
2254 $self->{PERL_ARCHIVE_AFTER} ||= '';
2255 $self->{EXPORT_LIST} ||= '';
2272 # The user who requests an installation directory explicitly
2273 # should not have to tell us an architecture installation directory
2274 # as well. We look if a directory exists that is named after the
2275 # architecture. If not we take it as a sign that it should be the
2276 # same as the requested installation directory. Otherwise we take
2278 for my $libpair ({l=>"privlib", a=>"archlib"},
2279 {l=>"sitelib", a=>"sitearch"},
2280 {l=>"vendorlib", a=>"vendorarch"},
2283 my $lib = "install$libpair->{l}";
2285 my $Arch = uc "install$libpair->{a}";
2286 if( $self->{$Lib} && ! $self->{$Arch} ){
2287 my($ilib) = $Config{$lib};
2289 $self->prefixify($Arch,$ilib,$self->{$Lib});
2291 unless (-d $self->{$Arch}) {
2292 print STDOUT "Directory $self->{$Arch} not found\n"
2294 $self->{$Arch} = $self->{$Lib};
2296 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
2306 Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the
2307 *PERLRUN* permutations.
2309 PERL is allowed to be miniperl
2310 FULLPERL must be a complete perl
2312 ABSPERL is PERL converted to an absolute path
2314 *PERLRUN contains everything necessary to run perl, find it's
2317 *PERLRUNINST is *PERLRUN + everything necessary to find the
2318 modules being built.
2326 foreach my $component ($self->{PERL_SRC}, $self->path(),
2329 push @defpath, $component if defined $component;
2332 # Build up a set of file names (not command names).
2333 my $thisperl = $self->canonpath($^X);
2334 $thisperl .= $Config{exe_ext} unless
2335 # VMS might have a file version # at the end
2336 $Is_VMS ? $thisperl =~ m/$Config{exe_ext}(;\d+)?$/i
2337 : $thisperl =~ m/$Config{exe_ext}$/i;
2339 # We need a relative path to perl when in the core.
2340 $thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE};
2342 my @perls = ($thisperl);
2343 push @perls, map { "$_$Config{exe_ext}" }
2344 ('perl', 'perl5', "perl$Config{version}");
2346 # miniperl has priority over all but the cannonical perl when in the
2347 # core. Otherwise its a last resort.
2348 my $miniperl = "miniperl$Config{exe_ext}";
2349 if( $self->{PERL_CORE} ) {
2350 splice @perls, 1, 0, $miniperl;
2353 push @perls, $miniperl;
2357 $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
2358 # don't check if perl is executable, maybe they have decided to
2359 # supply switches with perl
2361 # When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe.
2362 my $perl_name = 'perl';
2363 $perl_name = 'ndbgperl' if $Is_VMS &&
2364 defined $Config{usevmsdebug} && $Config{usevmsdebug} eq 'define';
2366 # XXX This logic is flawed. If "miniperl" is anywhere in the path
2367 # it will get confused. It should be fixed to work only on the filename.
2368 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2369 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/$perl_name/i
2370 unless $self->{FULLPERL};
2372 # Little hack to get around VMS's find_perl putting "MCR" in front
2374 $self->{ABSPERL} = $self->{PERL};
2375 my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2376 if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
2377 $self->{ABSPERL} = '$(PERL)';
2380 $self->{ABSPERL} = $self->rel2abs($self->{ABSPERL});
2381 $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2384 # Are we building the core?
2385 $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2387 # How do we run perl?
2388 foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2389 my $run = $perl.'RUN';
2391 $self->{$run} = "\$($perl)";
2393 # Make sure perl can find itself before it's installed.
2394 $self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
2395 if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2397 $self->{$perl.'RUNINST'} =
2398 sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2405 =item init_platform (o)
2407 Add MM_Unix_VERSION.
2409 =item platform_constants (o)
2416 $self->{MM_Unix_VERSION} = $VERSION;
2417 $self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '.
2418 '-Dfree=Perl_mfree -Drealloc=Perl_realloc '.
2419 '-Dcalloc=Perl_calloc';
2423 sub platform_constants {
2427 foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF))
2429 next unless defined $self->{$macro};
2430 $make_frag .= "$macro = $self->{$macro}\n";
2441 Called by init_main. Initializes PERL_*
2448 $self->{PERM_RW} = 644 unless defined $self->{PERM_RW};
2449 $self->{PERM_RWX} = 755 unless defined $self->{PERM_RWX};
2459 Sets up macros having to do with XS code. Currently just INST_STATIC,
2460 INST_DYNAMIC and INST_BOOT.
2467 if ($self->has_link_code()) {
2468 $self->{INST_STATIC} =
2469 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)');
2470 $self->{INST_DYNAMIC} =
2471 $self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)');
2472 $self->{INST_BOOT} =
2473 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs');
2475 $self->{INST_STATIC} = '';
2476 $self->{INST_DYNAMIC} = '';
2477 $self->{INST_BOOT} = '';
2483 Defines the install target.
2488 my($self, %attribs) = @_;
2492 install :: all pure_install doc_install
2494 install_perl :: all pure_perl_install doc_perl_install
2496 install_site :: all pure_site_install doc_site_install
2498 install_vendor :: all pure_vendor_install doc_vendor_install
2500 pure_install :: pure_$(INSTALLDIRS)_install
2502 doc_install :: doc_$(INSTALLDIRS)_install
2504 pure__install : pure_site_install
2505 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2507 doc__install : doc_site_install
2508 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2510 pure_perl_install ::
2511 $(NOECHO) $(MOD_INSTALL) \
2512 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2513 write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2514 $(INST_LIB) $(DESTINSTALLPRIVLIB) \
2515 $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
2516 $(INST_BIN) $(DESTINSTALLBIN) \
2517 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2518 $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
2519 $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
2520 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2521 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2524 pure_site_install ::
2525 $(NOECHO) $(MOD_INSTALL) \
2526 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2527 write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2528 $(INST_LIB) $(DESTINSTALLSITELIB) \
2529 $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
2530 $(INST_BIN) $(DESTINSTALLSITEBIN) \
2531 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2532 $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
2533 $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
2534 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2535 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2537 pure_vendor_install ::
2538 $(NOECHO) $(MOD_INSTALL) \
2539 read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2540 write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \
2541 $(INST_LIB) $(DESTINSTALLVENDORLIB) \
2542 $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
2543 $(INST_BIN) $(DESTINSTALLVENDORBIN) \
2544 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2545 $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
2546 $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
2549 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2550 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2551 -$(NOECHO) $(DOC_INSTALL) \
2552 "Module" "$(NAME)" \
2553 "installed into" "$(INSTALLPRIVLIB)" \
2554 LINKTYPE "$(LINKTYPE)" \
2555 VERSION "$(VERSION)" \
2556 EXE_FILES "$(EXE_FILES)" \
2557 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2560 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2561 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2562 -$(NOECHO) $(DOC_INSTALL) \
2563 "Module" "$(NAME)" \
2564 "installed into" "$(INSTALLSITELIB)" \
2565 LINKTYPE "$(LINKTYPE)" \
2566 VERSION "$(VERSION)" \
2567 EXE_FILES "$(EXE_FILES)" \
2568 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2570 doc_vendor_install ::
2571 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2572 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2573 -$(NOECHO) $(DOC_INSTALL) \
2574 "Module" "$(NAME)" \
2575 "installed into" "$(INSTALLVENDORLIB)" \
2576 LINKTYPE "$(LINKTYPE)" \
2577 VERSION "$(VERSION)" \
2578 EXE_FILES "$(EXE_FILES)" \
2579 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2584 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2586 uninstall_from_perldirs ::
2587 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2589 uninstall_from_sitedirs ::
2590 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2592 uninstall_from_vendordirs ::
2593 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2599 =item installbin (o)
2601 Defines targets to make and to install EXE_FILES.
2607 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2608 return "" unless @{$self->{EXE_FILES}};
2609 my(@m, $from, $to, %fromto, @to);
2610 for $from (@{$self->{EXE_FILES}}) {
2611 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2612 local($_) = $path; # for backwards compatibility
2613 $to = $self->libscan($path);
2614 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2617 @to = values %fromto;
2621 $fixin = $self->{PERL_CORE} ? '$(PERLRUN) ../../win32/bin/pl2bat.pl'
2625 $fixin = q{$(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"};
2629 EXE_FILES = @{$self->{EXE_FILES}}
2640 while (($from,$to) = each %fromto) {
2641 last unless defined $from;
2642 my $todir = dirname($to);
2644 $to : $from \$(FIRST_MAKEFILE) blibdirs
2645 \$(NOECHO) \$(RM_F) $to
2648 -\$(NOECHO) \$(CHMOD) \$(PERM_RWX) $to
2657 Defines the linkext target which in turn defines the LINKTYPE.
2662 my($self, %attribs) = @_;
2663 # LINKTYPE => static or dynamic or ''
2664 my($linktype) = defined $attribs{LINKTYPE} ?
2665 $attribs{LINKTYPE} : '$(LINKTYPE)';
2667 linkext :: $linktype
2674 Takes as arguments a directory name and a regular expression. Returns
2675 all entries in the directory that match the regular expression.
2681 my($dir, $regex) = @_;
2683 my $dh = new DirHandle;
2684 $dh->open($dir || ".") or return ();
2687 @ls = grep(/$regex/, @ls) if $regex;
2693 Simple subroutine to insert the macros defined by the macro attribute
2699 my($self,%attribs) = @_;
2701 while (($key,$val) = each %attribs){
2702 last unless defined $key;
2703 push @m, "$key = $val\n";
2710 Called by staticmake. Defines how to write the Makefile to produce a
2713 By default the Makefile produced includes all the static extensions in
2714 the perl library. (Purified versions of library files, e.g.,
2715 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2720 my($self, %attribs) = @_;
2721 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2722 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2725 # --- MakeMaker makeaperl section ---
2726 MAP_TARGET = $target
2727 FULLPERL = $self->{FULLPERL}
2729 return join '', @m if $self->{PARENT};
2731 my($dir) = join ":", @{$self->{DIR}};
2733 unless ($self->{MAKEAPERL}) {
2735 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2736 $(MAKE) -f $(MAKE_APERL_FILE) $@
2738 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2739 $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2740 $(NOECHO) $(PERLRUNINST) \
2741 Makefile.PL DIR=}, $dir, q{ \
2742 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2743 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2749 push @m, " \\\n\t\t$_";
2751 # push @m, map( " \\\n\t\t$_", @ARGV );
2759 my($cccmd, $linkcmd, $lperl);
2762 $cccmd = $self->const_cccmd($libperl);
2763 $cccmd =~ s/^CCCMD\s*=\s*//;
2764 $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2765 $cccmd .= " $Config{cccdlflags}"
2766 if ($Config{useshrplib} eq 'true');
2767 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2769 # The front matter of the linkcommand...
2770 $linkcmd = join ' ', "\$(CC)",
2771 grep($_, @Config{qw(ldflags ccdlflags)});
2772 $linkcmd =~ s/\s+/ /g;
2773 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2775 # Which *.a files could we make use of...
2778 File::Find::find(sub {
2779 return unless m/\Q$self->{LIB_EXT}\E$/;
2780 return if m/^libperl/ or m/^perl\Q$self->{LIB_EXT}\E$/;
2781 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2782 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2784 if( exists $self->{INCLUDE_EXT} ){
2789 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2793 # Throw away anything not explicitly marked for inclusion.
2794 # DynaLoader is implied.
2795 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2801 return unless $found;
2803 elsif( exists $self->{EXCLUDE_EXT} ){
2807 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2811 # Throw away anything explicitly marked for exclusion
2812 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2813 return if( $xx eq $excl );
2817 # don't include the installed version of this extension. I
2818 # leave this line here, although it is not necessary anymore:
2819 # I patched minimod.PL instead, so that Miniperl.pm won't
2820 # enclude duplicates
2822 # Once the patch to minimod.PL is in the distribution, I can
2824 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2826 $static{cwd() . "/" . $_}++;
2827 }, grep( -d $_, @{$searchdirs || []}) );
2829 # We trust that what has been handed in as argument, will be buildable
2830 $static = [] unless $static;
2831 @static{@{$static}} = (1) x @{$static};
2833 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2834 for (sort keys %static) {
2835 next unless /\Q$self->{LIB_EXT}\E\z/;
2836 $_ = dirname($_) . "/extralibs.ld";
2840 grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2845 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2846 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2847 # extralibs.all are computed correctly
2849 MAP_LINKCMD = $linkcmd
2850 MAP_PERLINC = @{$perlinc || []}
2852 join(" \\\n\t", reverse sort keys %static), "
2854 MAP_PRELIBS = $Config{perllibs} $Config{cryptlib}
2857 if (defined $libperl) {
2858 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2860 unless ($libperl && -f $lperl) { # Ilya's code...
2861 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2862 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2863 $libperl ||= "libperl$self->{LIB_EXT}";
2864 $libperl = "$dir/$libperl";
2865 $lperl ||= "libperl$self->{LIB_EXT}";
2866 $lperl = "$dir/$lperl";
2868 if (! -f $libperl and ! -f $lperl) {
2869 # We did not find a static libperl. Maybe there is a shared one?
2871 $lperl = $libperl = "$dir/$Config{libperl}";
2872 # SUNOS ld does not take the full path to a shared library
2873 $libperl = '' if $Is_SunOS4;
2877 print STDOUT "Warning: $libperl not found
2878 If you're going to build a static perl binary, make sure perl is installed
2879 otherwise ignore this warning\n"
2880 unless (-f $lperl || defined($self->{PERL_SRC}));
2883 # SUNOS ld does not take the full path to a shared library
2884 my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2887 MAP_LIBPERL = $libperl
2888 LLIBPERL = $llibperl
2892 \$(INST_ARCHAUTODIR)/extralibs.all: blibdirs ".join(" \\\n\t", @$extra).'
2893 $(NOECHO) $(RM_F) $@
2894 $(NOECHO) $(TOUCH) $@
2898 foreach $catfile (@$extra){
2899 push @m, "\tcat $catfile >> \$\@\n";
2903 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2904 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2905 \$(NOECHO) \$(ECHO) 'To install the new \"\$(MAP_TARGET)\" binary, call'
2906 \$(NOECHO) \$(ECHO) ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2907 \$(NOECHO) \$(ECHO) 'To remove the intermediate files say'
2908 \$(NOECHO) \$(ECHO) ' make -f $makefilename map_clean'
2910 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2912 push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2915 $tmp/perlmain.c: $makefilename}, q{
2916 $(NOECHO) $(ECHO) Writing $@
2917 $(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2918 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2921 push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain
2922 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2927 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2928 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2929 -$(NOECHO) $(DOC_INSTALL) \
2930 "Perl binary" "$(MAP_TARGET)" \
2931 MAP_STATIC "$(MAP_STATIC)" \
2932 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2933 MAP_LIBPERL "$(MAP_LIBPERL)" \
2934 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2939 inst_perl: pure_inst_perl doc_inst_perl
2941 pure_inst_perl: $(MAP_TARGET)
2942 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{
2947 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2955 Defines how to rewrite the Makefile.
2962 # We do not know what target was originally specified so we
2963 # must force a manual rerun to be sure. But as it should only
2964 # happen very rarely it is not a significant problem.
2966 $(OBJECT) : $(FIRST_MAKEFILE)
2967 ' if $self->{OBJECT};
2970 # We take a very conservative approach here, but it's worth it.
2971 # We move Makefile to Makefile.old here to avoid gnu make looping.
2972 $(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
2973 $(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?"
2974 $(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
2975 -$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
2976 -$(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
2977 -$(MAKE) -f $(MAKEFILE_OLD) clean $(DEV_NULL) || $(NOOP)
2978 $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2979 $(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
2980 $(NOECHO) $(ECHO) "==> Please rerun the make command. <=="
2991 Returns true, if the argument is likely to be a command.
2996 my($self,$file) = @_;
2997 return $file if -x $file && ! -d $file;
3002 =item needs_linking (o)
3004 Does this module need linking? Looks into subdirectory objects (see
3005 also has_link_code())
3012 $caller = (caller(0))[3];
3013 confess("needs_linking called too early") if
3014 $caller =~ /^ExtUtils::MakeMaker::/;
3015 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
3016 if ($self->has_link_code or $self->{MAKEAPERL}){
3017 $self->{NEEDS_LINKING} = 1;
3020 foreach $child (keys %{$self->{CHILDREN}}) {
3021 if ($self->{CHILDREN}->{$child}->needs_linking) {
3022 $self->{NEEDS_LINKING} = 1;
3026 return $self->{NEEDS_LINKING} = 0;
3031 misnamed method (will have to be changed). The MM_Unix method just
3032 returns the argument without further processing.
3034 On VMS used to insure that colons marking targets are preceded by
3035 space - most Unix Makes don't need this, but it's necessary under VMS
3036 to distinguish the target delimiter from a colon appearing as part of
3042 my($self,$text) = @_;
3046 =item parse_abstract
3048 parse a file and return what you think is the ABSTRACT
3052 sub parse_abstract {
3053 my($self,$parsefile) = @_;
3057 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3059 my $package = $self->{DISTNAME};
3060 $package =~ s/-/::/g;
3062 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3065 next unless /^($package\s-\s)(.*)/;
3075 parse a file and return what you think is $VERSION in this file set to.
3076 It will return the string "undef" if it can't figure out what $VERSION
3077 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
3078 are okay, but my $VERSION is not.
3083 my($self,$parsefile) = @_;
3088 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3091 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3092 next if $inpod || /^\s*#/;
3094 next unless /(?<!\\)([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
3096 package ExtUtils::MakeMaker::_version;
3105 $result = eval($eval);
3106 warn "Could not eval '$eval' in $parsefile: $@" if $@;
3111 $result = "undef" unless defined $result;
3118 Defines the string that is passed to recursive make calls in
3128 my($sep) = $Is_VMS ? ',' : '';
3131 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
3132 push @pasthru, "$key=\"\$($key)\"";
3135 foreach $key (qw(DEFINE INC)) {
3136 push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
3139 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
3145 Takes one argument, a file name, and returns the file name, if the
3146 argument is likely to be a perl script. On MM_Unix this is true for
3147 any ordinary, readable file.
3152 my($self,$file) = @_;
3153 return $file if -r $file && -f _;
3157 =item perldepend (o)
3159 Defines the dependency from all *.h files that come with the perl
3168 # Check for unpropogated config.sh changes. Should never happen.
3169 # We do NOT just update config.h because that is not sufficient.
3170 # An out of date config.h is not fatal but complains loudly!
3171 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
3172 -$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
3174 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
3175 $(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
3176 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
3177 } if $self->{PERL_SRC};
3179 return join "", @m unless $self->needs_linking;
3183 $(PERL_INC)/EXTERN.h \
3184 $(PERL_INC)/INTERN.h \
3185 $(PERL_INC)/XSUB.h \
3187 $(PERL_INC)/cc_runtime.h \
3188 $(PERL_INC)/config.h \
3191 $(PERL_INC)/dosish.h \
3192 $(PERL_INC)/embed.h \
3193 $(PERL_INC)/embedvar.h \
3194 $(PERL_INC)/fakethr.h \
3195 $(PERL_INC)/form.h \
3197 $(PERL_INC)/handy.h \
3199 $(PERL_INC)/intrpvar.h \
3200 $(PERL_INC)/iperlsys.h \
3201 $(PERL_INC)/keywords.h \
3203 $(PERL_INC)/nostdio.h \
3205 $(PERL_INC)/opcode.h \
3206 $(PERL_INC)/patchlevel.h \
3207 $(PERL_INC)/perl.h \
3208 $(PERL_INC)/perlio.h \
3209 $(PERL_INC)/perlsdio.h \
3210 $(PERL_INC)/perlsfio.h \
3211 $(PERL_INC)/perlvars.h \
3212 $(PERL_INC)/perly.h \
3214 $(PERL_INC)/pp_proto.h \
3215 $(PERL_INC)/proto.h \
3216 $(PERL_INC)/regcomp.h \
3217 $(PERL_INC)/regexp.h \
3218 $(PERL_INC)/regnodes.h \
3219 $(PERL_INC)/scope.h \
3221 $(PERL_INC)/thrdvar.h \
3222 $(PERL_INC)/thread.h \
3223 $(PERL_INC)/unixish.h \
3226 $(OBJECT) : $(PERL_HDRS)
3227 } if $self->{OBJECT};
3229 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
3237 Returns the attribute C<PERM_RW> or the string C<644>.
3238 Used as the string that is passed
3239 to the C<chmod> command to set the permissions for read/writeable files.
3240 MakeMaker chooses C<644> because it has turned out in the past that
3241 relying on the umask provokes hard-to-track bug reports.
3242 When the return value is used by the perl function C<chmod>, it is
3243 interpreted as an octal value.
3248 return shift->{PERM_RW};
3253 Returns the attribute C<PERM_RWX> or the string C<755>,
3254 i.e. the string that is passed
3255 to the C<chmod> command to set the permissions for executable files.
3261 return shift->{PERM_RWX};
3266 Defines target that copies all files in the hash PM to their
3267 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3273 my($autodir) = $self->catdir('$(INST_LIB)','auto');
3275 pm_to_blib: $(TO_INST_PM)
3278 my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']);
3279 pm_to_blib({\@ARGV}, '$autodir', '\$(PM_FILTER)')
3282 my @cmds = $self->split_command($pm_to_blib, %{$self->{PM}});
3284 $r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds;
3285 $r .= q{ $(NOECHO) $(TOUCH) $@};
3290 =item post_constants (o)
3292 Returns an empty string per default. Dedicated to overrides from
3293 within Makefile.PL after all constants have been defined.
3301 =item post_initialize (o)
3303 Returns an empty string per default. Used in Makefile.PLs to add some
3304 chunk of text to the Makefile after the object is initialized.
3308 sub post_initialize {
3314 Returns an empty string. Can be used in Makefile.PLs to write some
3315 text to the Makefile at the end.
3325 Defines target that creates a PPD (Perl Package Description) file
3326 for a binary distribution.
3333 if ($self->{ABSTRACT_FROM}){
3334 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3335 carp "WARNING: Setting ABSTRACT via file ".
3336 "'$self->{ABSTRACT_FROM}' failed\n";
3339 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
3341 my $abstract = $self->{ABSTRACT} || '';
3342 $abstract =~ s/\n/\\n/sg;
3343 $abstract =~ s/</</g;
3344 $abstract =~ s/>/>/g;
3346 my $author = $self->{AUTHOR} || '';
3347 $author =~ s/</</g;
3348 $author =~ s/>/>/g;
3350 my $ppd_xml = sprintf <<'PPD_HTML', $pack_ver, $abstract, $author;
3351 <SOFTPKG NAME="$(DISTNAME)" VERSION="%s">
3352 <TITLE>$(DISTNAME)</TITLE>
3353 <ABSTRACT>%s</ABSTRACT>
3357 $ppd_xml .= " <IMPLEMENTATION>\n";
3358 foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3359 my $pre_req = $prereq;
3360 $pre_req =~ s/::/-/g;
3361 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
3363 $ppd_xml .= sprintf <<'PPD_OUT', $pre_req, $dep_ver;
3364 <DEPENDENCY NAME="%s" VERSION="%s" />
3369 $ppd_xml .= sprintf <<'PPD_OUT', $Config{archname};
3370 <OS NAME="$(OSNAME)" />
3371 <ARCHITECTURE NAME="%s" />
3374 if ($self->{PPM_INSTALL_SCRIPT}) {
3375 if ($self->{PPM_INSTALL_EXEC}) {
3376 $ppd_xml .= sprintf qq{ <INSTALL EXEC="%s">%s</INSTALL>\n},
3377 $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3380 $ppd_xml .= sprintf qq{ <INSTALL>%s</INSTALL>\n},
3381 $self->{PPM_INSTALL_SCRIPT};
3385 my ($bin_location) = $self->{BINARY_LOCATION} || '';
3386 $bin_location =~ s/\\/\\\\/g;
3388 $ppd_xml .= sprintf <<'PPD_XML', $bin_location;
3389 <CODEBASE HREF="%s" />
3394 my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd');
3396 return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds;
3397 # Creates a PPD (Perl Package Description) for a binary distribution.
3406 $MM->prefixify($var, $prefix, $new_prefix, $default);
3408 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3409 replace it's $prefix with a $new_prefix.
3411 Should the $prefix fail to match I<AND> a PREFIX was given as an
3412 argument to WriteMakefile() it will set it to the $new_prefix +
3413 $default. This is for systems whose file layouts don't neatly fit into
3414 our ideas of prefixes.
3416 This is for heuristics which attempt to create directory structures
3417 that mirror those of the installed perl.
3421 $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3423 this will attempt to remove '/usr' from the front of the
3424 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3425 if necessary) and replace it with '/home/foo'. If this fails it will
3426 simply use '/home/foo/man/man1'.
3431 my($self,$var,$sprefix,$rprefix,$default) = @_;
3433 my $path = $self->{uc $var} ||
3434 $Config_Override{lc $var} || $Config{lc $var} || '';
3436 $rprefix .= '/' if $sprefix =~ m|/$|;
3438 print STDERR " prefixify $var => $path\n" if $Verbose >= 2;
3439 print STDERR " from $sprefix to $rprefix\n" if $Verbose >= 2;
3441 if( $self->{ARGS}{PREFIX} && $self->file_name_is_absolute($path) &&
3442 $path !~ s{^\Q$sprefix\E\b}{$rprefix}s )
3445 print STDERR " cannot prefix, using default.\n" if $Verbose >= 2;
3446 print STDERR " no default!\n" if !$default && $Verbose >= 2;
3448 $path = $self->catdir($rprefix, $default) if $default;
3451 print " now $path\n" if $Verbose >= 2;
3452 return $self->{uc $var} = $path;
3458 Defines targets to run *.PL files.
3464 return "" unless $self->{PL_FILES};
3466 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3467 my $list = ref($self->{PL_FILES}->{$plfile})
3468 ? $self->{PL_FILES}->{$plfile}
3469 : [$self->{PL_FILES}->{$plfile}];
3471 foreach $target (@$list) {
3477 \$(PERLRUNINST) $plfile $target
3486 Backslashes parentheses C<()> in command line arguments.
3487 Doesn't handle recursive Makefile C<$(...)> constructs,
3488 but handles simple ones.
3494 $arg =~ s/\$\((.+?)\)/\$\\\\($1\\\\)/g; # protect $(...)
3495 $arg =~ s/(?<!\\)([()])/\\$1/g; # quote unprotected
3496 $arg =~ s/\$\\\\\((.+?)\\\\\)/\$($1)/g; # unprotect $(...)
3502 Defines the realclean target.
3507 my($self, %attribs) = @_;
3511 # Delete temporary files (via clean) and also delete installed files
3512 realclean purge :: clean realclean_subdirs
3513 $(RM_RF) $(INST_AUTODIR) $(INST_ARCHAUTODIR)
3514 $(RM_RF) $(DISTVNAME)
3517 if( $self->has_link_code ){
3518 push(@m, " \$(RM_F) \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3519 push(@m, " \$(RM_F) \$(INST_STATIC)\n");
3522 my @files = values %{$self->{PM}};
3523 push @files, $attribs{FILES} if $attribs{FILES};
3524 push @files, '$(FIRST_MAKEFILE)', '$(MAKEFILE_OLD)';
3526 # Occasionally files are repeated several times from different sources
3527 { my(%f) = map { ($_,1) } @files; @files = keys %f; }
3529 # Issue a several little RM_F commands rather than risk creating a
3530 # very long command line (useful for extensions such as Encode
3531 # that have many files).
3533 foreach my $file (@files) {
3534 if (length($line) + length($file) > 200) {
3535 push @m, "\t\$(RM_F) $line\n";
3542 push @m, "\t\$(RM_F) $line\n" if $line;
3543 push(@m, "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
3549 =item realclean_subdirs_target
3551 my $make_frag = $MM->realclean_subdirs_target;
3553 Returns the realclean_subdirs target. This is used by the realclean
3554 target to call realclean on any subdirectories which contain Makefiles.
3558 sub realclean_subdirs_target {
3561 return <<'NOOP_FRAG' unless @{$self->{DIR}};
3566 my $rclean = "realclean_subdirs :\n";
3568 foreach my $dir (@{$self->{DIR}}){
3569 $rclean .= sprintf <<'RCLEAN', $dir, $dir;
3570 -cd %s && $(TEST_F) $(MAKEFILE_OLD) && $(MAKE) -f $(MAKEFILE_OLD) realclean
3571 -cd %s && $(TEST_F) $(FIRST_MAKEFILE) && $(MAKE) realclean
3580 =item replace_manpage_separator
3582 my $man_name = $MM->replace_manpage_separator($file_path);
3584 Takes the name of a package, which may be a nested package, in the
3585 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3586 safe for a man page file name. Returns the replacement.
3590 sub replace_manpage_separator {
3591 my($self,$man) = @_;
3603 my($self, $cmd, $switches) = @_;
3604 $switches = [] unless defined $switches;
3606 # Strip leading and trailing newlines
3610 my @cmds = split /\n/, $cmd;
3611 $cmd = join " \n\t-e ", map $self->quote_literal($_), @cmds;
3612 $cmd = $self->escape_newlines($cmd);
3614 $switches = join ' ', @$switches;
3616 return qq{\$(PERLRUN) $switches -e $cmd};
3625 my($self, $text) = @_;
3627 # I think all we have to quote is single quotes and I think
3628 # this is a safe way to do it.
3629 $text =~ s{'}{'\\''}g;
3635 =item escape_newlines
3639 sub escape_newlines {
3640 my($self, $text) = @_;
3642 $text =~ s{\n}{\\\n}g;
3650 Using POSIX::ARG_MAX. Otherwise falling back to 4096.
3657 if (!defined $self->{_MAX_EXEC_LEN}) {
3658 if (my $arg_max = eval { require POSIX; &POSIX::ARG_MAX }) {
3659 $self->{_MAX_EXEC_LEN} = $arg_max;
3661 else { # POSIX minimum exec size
3662 $self->{_MAX_EXEC_LEN} = 4096;
3666 return $self->{_MAX_EXEC_LEN};
3672 Defines the static target.
3677 # --- Static Loading Sections ---
3681 ## $(INST_PM) has been moved to the all: target.
3682 ## It remains here for awhile to allow for old usage: "make static"
3683 static :: $(FIRST_MAKEFILE) $(INST_STATIC)
3688 =item static_lib (o)
3690 Defines how to produce the *.a (or equivalent) files.
3696 return '' unless $self->has_link_code;
3701 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) blibdirs
3705 # If this extension has its own library (eg SDBM_File)
3706 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3707 push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB};
3708 $(CP) $(MYEXTLIB) $@
3712 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3713 # Prefer the absolute pathed ar if available so that PATH
3714 # doesn't confuse us. Perl itself is built with the full_ar.
3719 push @m, sprintf <<'MAKE_FRAG', $ar;
3720 $(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
3721 $(CHMOD) $(PERM_RWX) $@
3722 $(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3725 # Old mechanism - still available:
3726 push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
3727 $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3733 =item staticmake (o)
3740 my($self, %attribs) = @_;
3743 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3745 # And as it's not yet built, we add the current extension
3746 # but only if it has some C code (or XS code, which implies C code)
3747 if (@{$self->{C}}) {
3748 @static = $self->catfile($self->{INST_ARCHLIB},
3751 "$self->{BASEEXT}$self->{LIB_EXT}"
3755 # Either we determine now, which libraries we will produce in the
3756 # subdirectories or we do it at runtime of the make.
3758 # We could ask all subdir objects, but I cannot imagine, why it
3759 # would be necessary.
3761 # Instead we determine all libraries for the new perl at
3763 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3765 $self->makeaperl(MAKE => $self->{MAKEFILE},
3766 DIRS => \@searchdirs,
3769 TARGET => $self->{MAP_TARGET},
3771 LIBPERL => $self->{LIBPERL_A}
3777 Helper subroutine for subdirs
3782 my($self, $subdir) = @_;
3783 return sprintf <<'EOT', $subdir;
3786 $(NOECHO)cd %s && $(MAKE) -f $(FIRST_MAKEFILE) all $(PASTHRU)
3792 Defines targets to process subdirectories.
3797 # --- Sub-directory Sections ---
3800 # This method provides a mechanism to automatically deal with
3801 # subdirectories containing further Makefile.PL scripts.
3802 # It calls the subdir_x() method for each subdirectory.
3803 foreach $dir (@{$self->{DIR}}){
3804 push(@m, $self->subdir_x($dir));
3805 #### print "Including $dir subdirectory\n";
3809 # The default clean, realclean and test targets in this Makefile
3810 # have automatically been given entries for each subdir.
3814 push(@m, "\n# none")
3821 Defines the test targets.
3826 # --- Test and Installation Sections ---
3828 my($self, %attribs) = @_;
3829 my $tests = $attribs{TESTS} || '';
3830 if (!$tests && -d 't') {
3831 $tests = $self->find_tests;
3833 # note: 'test.pl' name is also hardcoded in init_dirscan()
3837 TEST_TYPE=test_\$(LINKTYPE)
3842 testdb :: testdb_\$(LINKTYPE)
3844 test :: \$(TEST_TYPE)
3848 push(@m, map(qq{\t\$(NOECHO) \$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q[\$(MAKE) test \$(PASTHRU)]" \$(FIRST_MAKEFILE)\n}, @{$self->{DIR}}));
3851 push(@m, map("\t\$(NOECHO) cd $_ && \$(TEST_F) \$(FIRST_MAKEFILE) && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3854 push(@m, "\t\$(NOECHO) \$(ECHO) 'No tests defined for \$(NAME) extension.'\n")
3855 unless $tests or -f "test.pl" or @{$self->{DIR}};
3858 push(@m, "test_dynamic :: pure_all\n");
3859 push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3861 push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3865 push(@m, "testdb_dynamic :: pure_all\n");
3866 push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3870 # Occasionally we may face this degenerate target:
3871 push @m, "test_ : test_dynamic\n\n";
3873 if ($self->needs_linking()) {
3874 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3875 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3876 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3878 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3879 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3882 push @m, "test_static :: test_dynamic\n";
3883 push @m, "testdb_static :: testdb_dynamic\n";
3888 =item test_via_harness (override)
3890 For some reason which I forget, Unix machines like to have
3891 PERL_DL_NONLAZY set for tests.
3895 sub test_via_harness {
3896 my($self, $perl, $tests) = @_;
3897 return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3900 =item test_via_script (override)
3902 Again, the PERL_DL_NONLAZY thing.
3906 sub test_via_script {
3907 my($self, $perl, $script) = @_;
3908 return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3912 =item tools_other (o)
3914 my $make_frag = $MM->tools_other;
3916 Returns a make fragment containing definitions for:
3918 SHELL, CHMOD, CP, MV, NOOP, NOECHO, RM_F, RM_RF, TEST_F, TOUCH,
3919 DEV_NULL, UMASK_NULL, MKPATH, EQUALIZE_TIMESTAMP,
3920 WARN_IF_OLD_PACKLIST, UNINST, VERBINST, MOD_INSTALL, DOC_INSTALL and
3923 init_others() initializes all these values.
3931 for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH
3932 UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP
3935 MOD_INSTALL DOC_INSTALL UNINSTALL
3936 WARN_IF_OLD_PACKLIST
3939 next unless defined $self->{$tool};
3940 push @m, "$tool = $self->{$tool}\n";
3946 =item tool_xsubpp (o)
3948 Determines typemaps, xsubpp version, prototype behaviour.
3954 return "" unless $self->needs_linking;
3957 foreach my $dir (@INC) {
3958 $xsdir = $self->catdir($dir, 'ExtUtils');
3959 if( -r $self->catfile($xsdir, "xsubpp") ) {
3964 my $tmdir = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3965 my(@tmdeps) = $self->catfile($tmdir,'typemap');
3966 if( $self->{TYPEMAPS} ){
3968 foreach $typemap (@{$self->{TYPEMAPS}}){
3969 if( ! -f $typemap ){
3970 warn "Typemap $typemap not found.\n";
3973 push(@tmdeps, $typemap);
3977 push(@tmdeps, "typemap") if -f "typemap";
3978 my(@tmargs) = map("-typemap $_", @tmdeps);
3979 if( exists $self->{XSOPT} ){
3980 unshift( @tmargs, $self->{XSOPT} );
3984 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3988 XSUBPP = \$(XSUBPPDIR)/xsubpp
3989 XSPROTOARG = $self->{XSPROTOARG}
3990 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3991 XSUBPPARGS = @tmargs
3999 Build man pages, too
4006 return <<'MAKE_EXT';
4007 all :: pure_all manifypods
4012 =item top_targets (o)
4014 Defines the targets all, subdirs, config, and O_FILES
4019 # --- Target Sections ---
4024 push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'};
4027 pure_all :: config pm_to_blib subdirs linkext
4030 subdirs :: $(MYEXTLIB)
4033 config :: $(FIRST_MAKEFILE) blibdirs
4038 $(O_FILES): $(H_FILES)
4039 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
4043 perldoc ExtUtils::MakeMaker
4051 Obsolete, deprecated method. Not used since Version 5.21.
4056 # --- perllocal.pod section ---
4057 my($self,$what,$name,@attribs)=@_;
4058 my $time = localtime;
4059 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
4060 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
4061 print "\n\n=back\n\n";
4066 Defines the suffix rules to compile XS files to C.
4072 return '' unless $self->needs_linking();
4075 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4081 Defines the suffix rules to compile XS files to C++.
4087 return '' unless $self->needs_linking();
4090 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
4096 Defines suffix rules to go from XS to object files directly. This is
4097 only intended for broken make implementations.
4101 sub xs_o { # many makes are too dumb to use xs_c then c_o
4103 return '' unless $self->needs_linking();
4106 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4107 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
4118 L<ExtUtils::MakeMaker>