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 fileparse);
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 pm_to_blib
299 *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
300 $(BOOTSTRAP) $(BASEEXT).bso
301 $(BASEEXT).def lib$(BASEEXT).def
302 $(BASEEXT).exp $(BASEEXT).x
305 push(@otherfiles, qw[*.kp]);
308 push(@otherfiles, qw[core core.*perl.*.? *perl.core]);
311 push(@otherfiles, map { "core." . "[0-9]"x$_ } (1..5));
314 push @m, "\t-\$(RM_RF) @otherfiles\n";
315 # See realclean and ext/utils/make_ext for usage of Makefile.old
317 "\t-\$(MV) \$(FIRST_MAKEFILE) \$(MAKEFILE_OLD) \$(DEV_NULL)\n");
319 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
324 =item clean_subdirs_target
326 my $make_frag = $MM->clean_subdirs_target;
328 Returns the clean_subdirs target. This is used by the clean target to
329 call clean on any subdirectories which contain Makefiles.
333 sub clean_subdirs_target {
336 # No subdirectories, no cleaning.
337 return <<'NOOP_FRAG' unless @{$self->{DIR}};
343 my $clean = "clean_subdirs :\n";
345 for my $dir (@{$self->{DIR}}) {
346 $clean .= sprintf <<'MAKE_FRAG', $dir;
347 -cd %s && $(TEST_F) $(FIRST_MAKEFILE) && $(MAKE) clean
355 =item const_cccmd (o)
357 Returns the full compiler call for C programs and stores the
358 definition in CONST_CCCMD.
363 my($self,$libperl)=@_;
364 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
365 return '' unless $self->needs_linking();
366 return $self->{CONST_CCCMD} =
367 q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
368 $(CCFLAGS) $(OPTIMIZE) \\
369 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
370 $(XS_DEFINE_VERSION)};
373 =item const_config (o)
375 Defines a couple of constants in the Makefile that are imported from
381 # --- Constants Sections ---
385 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
386 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
388 foreach $m (@{$self->{CONFIG}}){
389 # SITE*EXP macros are defined in &constants; avoid duplicates here
390 next if $once_only{$m};
391 $self->{uc $m} = quote_paren($self->{uc $m});
392 push @m, uc($m) , ' = ' , $self->{uc $m}, "\n";
398 =item const_loadlibs (o)
400 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
401 L<ExtUtils::Liblist> for details.
407 return "" unless $self->needs_linking;
410 # $self->{NAME} might depend on some other libraries:
411 # See ExtUtils::Liblist for details
416 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
418 next unless defined $self->{$tmp};
419 push @m, "$tmp = $self->{$tmp}\n";
426 my $make_frag = $mm->constants;
428 Prints out macros for lots of constants.
438 AR_STATIC_ARGS DIRFILESEP
440 VERSION VERSION_MACRO VERSION_SYM DEFINE_VERSION
441 XS_VERSION XS_VERSION_MACRO XS_DEFINE_VERSION
442 INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB
443 INST_MAN1DIR INST_MAN3DIR
447 PERLPREFIX SITEPREFIX VENDORPREFIX
449 (map { ("INSTALL".$_,
451 } $self->installvars),
456 FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE
457 PERLMAINCC PERL_SRC PERL_INC
458 PERL FULLPERL ABSPERL
459 PERLRUN FULLPERLRUN ABSPERLRUN
460 PERLRUNINST FULLPERLRUNINST ABSPERLRUNINST
466 next unless defined $self->{$macro};
468 # pathnames can have sharp signs in them; escape them so
469 # make doesn't think it is a comment-start character.
470 $self->{$macro} =~ s/#/\\#/g;
471 push @m, "$macro = $self->{$macro}\n";
475 MAKEMAKER = $self->{MAKEMAKER}
476 MM_VERSION = $self->{MM_VERSION}
477 MM_REVISION = $self->{MM_REVISION}
481 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
482 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
483 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
484 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
488 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
489 LDFROM LINKTYPE PM_FILTER
492 next unless defined $self->{$macro};
493 push @m, "$macro = $self->{$macro}\n";
497 # Handy lists of source code files:
498 XS_FILES = ".$self->wraplist(sort keys %{$self->{XS}})."
499 C_FILES = ".$self->wraplist(@{$self->{C}})."
500 O_FILES = ".$self->wraplist(@{$self->{O_FILES}})."
501 H_FILES = ".$self->wraplist(@{$self->{H}})."
502 MAN1PODS = ".$self->wraplist(sort keys %{$self->{MAN1PODS}})."
503 MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})."
508 # Where is the Config information that we are using/depend on
509 CONFIGDEP = $(PERL_ARCHLIB)$(DIRFILESEP)Config.pm $(PERL_INC)$(DIRFILESEP)config.h
514 # Where to build things
515 INST_LIBDIR = $self->{INST_LIBDIR}
516 INST_ARCHLIBDIR = $self->{INST_ARCHLIBDIR}
518 INST_AUTODIR = $self->{INST_AUTODIR}
519 INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR}
521 INST_STATIC = $self->{INST_STATIC}
522 INST_DYNAMIC = $self->{INST_DYNAMIC}
523 INST_BOOT = $self->{INST_BOOT}
529 EXPORT_LIST = $self->{EXPORT_LIST}
530 PERL_ARCHIVE = $self->{PERL_ARCHIVE}
531 PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER}
536 TO_INST_PM = ".$self->wraplist(sort keys %{$self->{PM}})."
538 PM_TO_BLIB = ".$self->wraplist(%{$self->{PM}})."
547 Same as macro for the depend attribute.
552 my($self,%attribs) = @_;
554 while (($key,$val) = each %attribs){
555 last unless defined $key;
556 push @m, "$key : $val\n";
563 Takes an array of directories that need to exist and returns a
564 Makefile entry for a .exists file in these directories. Returns
565 nothing, if the entry has already been processed. We're helpless
566 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
567 them get an entry, that's why we use "::".
572 # --- Make-Directories section (internal method) ---
573 # dir_target(@array) returns a Makefile entry for the file .exists in each
574 # named directory. Returns nothing, if the entry has already been processed.
575 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
576 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
577 # prerequisite, because there has to be one, something that doesn't change
580 my($self,@dirs) = @_;
581 my(@m,$dir,$targdir);
582 foreach $dir (@dirs) {
583 my($src) = $self->catfile($self->{PERL_INC},'perl.h');
584 my($targ) = $self->catfile($dir,'.exists');
585 # catfile may have adapted syntax of $dir to target OS, so...
586 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
587 ($targdir = $targ) =~ s:/?\.exists\z::;
589 else { # while elsewhere we expect to see the dir separator in $targ
590 $targdir = dirname($targ);
592 next if $self->{DIR_TARGET}{$self}{$targdir}++;
595 \$(NOECHO) \$(MKPATH) $targdir
596 \$(NOECHO) \$(EQUALIZE_TIMESTAMP) $src $targ
599 -\$(NOECHO) \$(CHMOD) \$(PERM_RWX) $targdir
609 Defines the DESTDIR and DEST* variables paralleling the INSTALL*.
617 $self->{DESTDIR} ||= '';
619 # Make DEST variables.
620 foreach my $var ($self->installvars) {
621 my $destvar = 'DESTINSTALL'.$var;
622 $self->{$destvar} ||= '$(DESTDIR)$(INSTALL'.$var.')';
631 Defines a lot of macros for distribution support.
633 macro description default
635 TAR tar command to use tar
636 TARFLAGS flags to pass to TAR cvf
638 ZIP zip command to use zip
639 ZIPFLAGS flags to pass to ZIP -r
641 COMPRESS compression command to gzip --best
643 SUFFIX suffix to put on .gz
646 SHAR shar command to use shar
648 PREOP extra commands to run before
650 POSTOP extra commands to run after
653 TO_UNIX a command to convert linefeeds
654 to Unix style in your archive
656 CI command to checkin your ci -u
657 sources to version control
658 RCS_LABEL command to label your sources rcs -Nv$(VERSION_SYM): -q
661 DIST_CP $how argument to manicopy() best
662 when the distdir is created
664 DIST_DEFAULT default target to use to tardist
665 create a distribution
667 DISTVNAME name of the resulting archive $(DISTNAME)-$(VERSION)
675 $self->{TAR} ||= 'tar';
676 $self->{TARFLAGS} ||= 'cvf';
677 $self->{ZIP} ||= 'zip';
678 $self->{ZIPFLAGS} ||= '-r';
679 $self->{COMPRESS} ||= 'gzip --best';
680 $self->{SUFFIX} ||= '.gz';
681 $self->{SHAR} ||= 'shar';
682 $self->{PREOP} ||= '$(NOECHO) $(NOOP)'; # eg update MANIFEST
683 $self->{POSTOP} ||= '$(NOECHO) $(NOOP)'; # eg remove the distdir
684 $self->{TO_UNIX} ||= '$(NOECHO) $(NOOP)';
686 $self->{CI} ||= 'ci -u';
687 $self->{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q';
688 $self->{DIST_CP} ||= 'best';
689 $self->{DIST_DEFAULT} ||= 'tardist';
691 ($self->{DISTNAME} = $self->{NAME}) =~ s{::}{-}g unless $self->{DISTNAME};
692 $self->{DISTVNAME} ||= $self->{DISTNAME}.'-'.$self->{VERSION};
698 my $dist_macros = $mm->dist(%overrides);
700 Generates a make fragment defining all the macros initialized in
703 %overrides can be used to override any of the above.
708 my($self, %attribs) = @_;
712 TAR TARFLAGS ZIP ZIPFLAGS COMPRESS SUFFIX SHAR
714 CI RCS_LABEL DIST_CP DIST_DEFAULT
718 my $value = $attribs{$key} || $self->{$key};
719 $make .= "$key = $value\n";
725 =item dist_basics (o)
727 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
734 return <<'MAKE_FRAG';
735 distclean :: realclean distcheck
739 $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
742 $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
745 $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
747 veryclean : realclean
748 $(RM_F) *~ *.orig */*~ */*.orig
756 Defines a check in target for RCS.
764 $(PERLRUN) "-MExtUtils::Manifest=maniread" \\
765 -e "@all = keys %{ maniread() };" \\
766 -e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \\
767 -e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});"
773 my $dist_make_fragment = $MM->dist_core;
775 Puts the targets necessary for 'make dist' together into one make
784 foreach my $target (qw(dist tardist uutardist tarfile zipdist zipfile
787 my $method = $target.'_target';
789 $make_frag .= $self->$method();
798 my $make_frag = $MM->dist_target;
800 Returns the 'dist' target to make an archive for distribution. This
801 target simply checks to make sure the Makefile is up-to-date and
802 depends on $(DIST_DEFAULT).
809 my $date_check = $self->oneliner(<<'CODE', ['-l']);
810 print 'Warning: Makefile possibly out of date with $(VERSION_FROM)'
811 if -e '$(VERSION_FROM)' and -M '$(VERSION_FROM)' < -M '$(FIRST_MAKEFILE)';
814 return sprintf <<'MAKE_FRAG', $date_check;
815 dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
820 =item B<tardist_target>
822 my $make_frag = $MM->tardist_target;
824 Returns the 'tardist' target which is simply so 'make tardist' works.
825 The real work is done by the dynamically named tardistfile_target()
826 method, tardist should have that as a dependency.
833 return <<'MAKE_FRAG';
834 tardist : $(DISTVNAME).tar$(SUFFIX)
839 =item B<zipdist_target>
841 my $make_frag = $MM->zipdist_target;
843 Returns the 'zipdist' target which is simply so 'make zipdist' works.
844 The real work is done by the dynamically named zipdistfile_target()
845 method, zipdist should have that as a dependency.
852 return <<'MAKE_FRAG';
853 zipdist : $(DISTVNAME).zip
858 =item B<tarfile_target>
860 my $make_frag = $MM->tarfile_target;
862 The name of this target is the name of the tarball generated by
863 tardist. This target does the actual work of turning the distdir into
871 return <<'MAKE_FRAG';
872 $(DISTVNAME).tar$(SUFFIX) : distdir
875 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
876 $(RM_RF) $(DISTVNAME)
877 $(COMPRESS) $(DISTVNAME).tar
884 my $make_frag = $MM->zipfile_target;
886 The name of this target is the name of the zip file generated by
887 zipdist. This target does the actual work of turning the distdir into
895 return <<'MAKE_FRAG';
896 $(DISTVNAME).zip : distdir
898 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
899 $(RM_RF) $(DISTVNAME)
904 =item uutardist_target
906 my $make_frag = $MM->uutardist_target;
908 Converts the tarfile into a uuencoded file
912 sub uutardist_target {
915 return <<'MAKE_FRAG';
916 uutardist : $(DISTVNAME).tar$(SUFFIX)
917 uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu
924 my $make_frag = $MM->shdist_target;
926 Converts the distdir into a shell archive.
933 return <<'MAKE_FRAG';
936 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
937 $(RM_RF) $(DISTVNAME)
944 Defines the scratch directory target that will hold the distribution
945 before tar-ing (or shar-ing).
949 # For backwards compatibility.
950 *dist_dir = *distdir;
955 return <<'MAKE_FRAG';
956 distdir : metafile metafile_addtomanifest
957 $(RM_RF) $(DISTVNAME)
958 $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
959 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
967 Defines a target that produces the distribution in the
968 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
978 cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
979 cd $(DISTVNAME) && $(MAKE) $(PASTHRU)
980 cd $(DISTVNAME) && $(MAKE) test $(PASTHRU)
987 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
993 my($self,%attribs) = @_;
995 return '' unless ($Is_AIX && $self->needs_linking() );
997 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
998 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
999 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
1003 dynamic :: $self->{BASEEXT}.exp
1005 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
1008 static :: $self->{BASEEXT}.exp
1010 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
1013 $self->{BASEEXT}.exp: Makefile.PL
1014 ",' $(PERLRUN) -e \'use ExtUtils::Mksymlists; \\
1015 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
1016 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
1017 ', "DL_VARS" => ', neatvalue($vars), ');\'
1025 Defines the dynamic target.
1030 # --- Dynamic Loading Sections ---
1034 dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
1039 =item dynamic_bs (o)
1041 Defines targets for bootstrap files.
1046 my($self, %attribs) = @_;
1049 ' unless $self->has_link_code();
1051 return <<'MAKE_FRAG';
1052 BOOTSTRAP = $(BASEEXT).bs
1054 # As Mkbootstrap might not write a file (if none is required)
1055 # we use touch to prevent make continually trying to remake it.
1056 # The DynaLoader only reads a non-empty file.
1057 $(BOOTSTRAP): $(FIRST_MAKEFILE) $(BOOTDEP) $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
1058 $(NOECHO) $(ECHO) "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1059 $(NOECHO) $(PERLRUN) \
1060 "-MExtUtils::Mkbootstrap" \
1061 -e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');"
1062 $(NOECHO) $(TOUCH) $(BOOTSTRAP)
1063 $(CHMOD) $(PERM_RW) $@
1065 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
1066 $(NOECHO) $(RM_RF) $(INST_BOOT)
1067 -$(CP) $(BOOTSTRAP) $(INST_BOOT)
1068 $(CHMOD) $(PERM_RW) $@
1072 =item dynamic_lib (o)
1074 Defines how to produce the *.so (or equivalent) files.
1079 my($self, %attribs) = @_;
1080 return '' unless $self->needs_linking(); #might be because of a subdir
1082 return '' unless $self->has_link_code;
1084 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1085 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1086 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1087 my($ldfrom) = '$(LDFROM)';
1088 $armaybe = 'ar' if ($Is_OSF and $armaybe eq ':');
1090 my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
1091 my $ld_fix = $Is_OS2 ? '|| ( $(RM_F) $@ && sh -c false )' : '';
1093 # This section creates the dynamically loadable $(INST_DYNAMIC)
1094 # from $(OBJECT) and possibly $(MYEXTLIB).
1095 ARMAYBE = '.$armaybe.'
1096 OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
1097 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1098 INST_DYNAMIC_FIX = '.$ld_fix.'
1100 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DIRFILESEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
1102 if ($armaybe ne ':'){
1103 $ldfrom = 'tmp$(LIB_EXT)';
1104 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1105 push(@m,' $(RANLIB) '."$ldfrom\n");
1107 $ldfrom = "-all $ldfrom -none" if $Is_OSF;
1109 # The IRIX linker doesn't use LD_RUN_PATH
1110 my $ldrun = $Is_IRIX && $self->{LD_RUN_PATH} ?
1111 qq{-rpath "$self->{LD_RUN_PATH}"} : '';
1113 # For example in AIX the shared objects/libraries from previous builds
1114 # linger quite a while in the shared dynalinker cache even when nobody
1115 # is using them. This is painful if one for instance tries to restart
1116 # a failed build because the link command will fail unnecessarily 'cos
1117 # the shared object/library is 'busy'.
1118 push(@m,' $(RM_F) $@
1121 my $libs = '$(LDLOADLIBS)';
1124 # Use nothing on static perl platforms, and to the flags needed
1125 # to link against the shared libperl library on shared perl
1126 # platforms. We peek at lddlflags to see if we need -Wl,-R
1127 # or -R to add paths to the run-time library search path.
1128 if ($Config{'useshrplib'}) {
1129 if ($Config{'lddlflags'} =~ /-Wl,-R/) {
1130 $libs .= ' -L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -lperl';
1131 } elsif ($Config{'lddlflags'} =~ /-R/) {
1132 $libs .= ' -L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -lperl';
1138 ' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1139 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) '.$libs.' $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST) $(INST_DYNAMIC_FIX)');
1141 $(CHMOD) $(PERM_RWX) $@
1144 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1150 Deprecated method. Use libscan instead.
1155 my($self,$path) = @_;
1161 Called by init_others, and calls ext ExtUtils::Liblist. See
1162 L<ExtUtils::Liblist> for details.
1167 my($self,$libs) = @_;
1168 require ExtUtils::Liblist;
1169 $self->ext($libs, $Verbose);
1174 Finds the executables PERL and FULLPERL
1179 my($self, $ver, $names, $dirs, $trace) = @_;
1182 print "Looking for perl $ver by these names:
1189 my $stderr_duped = 0;
1192 if( open(STDERR_COPY, '>&STDERR') ) {
1197 find_perl() can't dup STDERR: $!
1198 You might see some garbage while we search for Perl
1203 foreach $name (@$names){
1204 foreach $dir (@$dirs){
1205 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1207 if ($self->file_name_is_absolute($name)) { # /foo/bar
1209 } elsif ($self->canonpath($name) eq
1210 $self->canonpath(basename($name))) { # foo
1211 $abs = $self->catfile($dir, $name);
1213 $abs = $self->catfile($Curdir, $name);
1215 print "Checking $abs\n" if ($trace >= 2);
1216 next unless $self->maybe_command($abs);
1217 print "Executing $abs\n" if ($trace >= 2);
1219 my $version_check = qq{$abs -e "require $ver; print qq{VER_OK\n}"};
1220 # To avoid using the unportable 2>&1 to supress STDERR,
1221 # we close it before running the command.
1222 # However, thanks to a thread library bug in many BSDs
1223 # ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 )
1224 # we cannot use the fancier more portable way in here
1225 # but instead need to use the traditional 2>&1 construct.
1227 $val = `$version_check 2>&1`;
1229 close STDERR if $stderr_duped;
1230 $val = `$version_check`;
1231 open STDERR, '>&STDERR_COPY' if $stderr_duped;
1234 if ($val =~ /^VER_OK/) {
1235 print "Using PERL=$abs\n" if $trace;
1237 } elsif ($trace >= 2) {
1238 print "Result: '$val'\n";
1242 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1243 0; # false and not empty
1248 my $test = $mm->find_tests;
1250 Returns a string suitable for feeding to the shell to return all
1262 =head2 Methods to actually produce chunks of text for the Makefile
1264 The methods here are called for each MakeMaker object in the order
1265 specified by @ExtUtils::MakeMaker::MM_Sections.
1273 Inserts the sharpbang or equivalent magic number to a set of @files.
1277 sub fixin { # stolen from the pink Camel book, more or less
1278 my($self, @files) = @_;
1280 my($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
1281 for my $file (@files) {
1282 my $file_new = "$file.new";
1283 my $file_bak = "$file.bak";
1287 open(FIXIN, $file) or croak "Can't process '$file': $!";
1289 chomp(my $line = <FIXIN>);
1290 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1291 # Now figure out the interpreter name.
1292 my($cmd,$arg) = split ' ', $line, 2;
1295 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1297 if ($cmd eq "perl") {
1298 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1299 $interpreter = $Config{startperl};
1300 $interpreter =~ s,^\#!,,;
1302 $interpreter = $Config{perlpath};
1305 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1308 foreach $dir (@absdirs) {
1309 if ($self->maybe_command($cmd)) {
1310 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1311 $interpreter = $self->catfile($dir,$cmd);
1315 # Figure out how to invoke interpreter on this machine.
1319 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1320 # this is probably value-free on DOSISH platforms
1322 $shb .= "$Config{'sharpbang'}$interpreter";
1323 $shb .= ' ' . $arg if defined $arg;
1327 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1328 if 0; # not running under some shell
1329 } unless $Is_Win32; # this won't work on win32, so don't
1331 warn "Can't find $cmd in PATH, $file unchanged"
1336 unless ( open(FIXOUT,">$file_new") ) {
1337 warn "Can't create new $file: $!\n";
1341 # Print out the new #! line (or equivalent).
1344 print FIXOUT $shb, <FIXIN>;
1348 chmod 0666, $file_bak;
1350 unless ( rename($file, $file_bak) ) {
1351 warn "Can't rename $file to $file_bak: $!";
1354 unless ( rename($file_new, $file) ) {
1355 warn "Can't rename $file_new to $file: $!";
1356 unless ( rename($file_bak, $file) ) {
1357 warn "Can't rename $file_bak back to $file either: $!";
1358 warn "Leaving $file renamed as $file_bak\n";
1364 close(FIXIN) if fileno(FIXIN);
1365 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1377 '# Phony target to force checking subdirectories.
1385 Guess the name of this package by examining the working directory's
1386 name. MakeMaker calls this only if the developer has not supplied a
1396 my $name = basename(cwd());
1397 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1398 # strip minus or underline
1399 # followed by a float or some such
1400 print "Warning: Guessing NAME [$name] from current directory name.\n";
1406 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1407 object that need a compiler. Does not descend into subdirectories as
1408 needs_linking() does.
1414 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1415 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1416 $self->{HAS_LINK_CODE} = 1;
1419 return $self->{HAS_LINK_CODE} = 0;
1425 Scans the directory structure and initializes DIR, XS, XS_FILES, PM,
1426 C, C_FILES, O_FILES, H, H_FILES, PL_FILES, MAN*PODS, EXE_FILES.
1428 Called by init_main.
1432 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1434 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1437 @ignore{qw(Makefile.PL test.pl t)} = (1,1,1);
1439 # ignore the distdir
1440 $Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1
1441 : $ignore{$self->{DISTVNAME}} = 1;
1443 @ignore{map lc, keys %ignore} = values %ignore if $Is_VMS;
1445 foreach $name ($self->lsdir($Curdir)){
1446 next if $name =~ /\#/;
1447 next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
1448 next unless $self->libscan($name);
1450 next if -l $name; # We do not support symlinks at all
1451 next if $self->{NORECURS};
1452 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1453 } elsif ($name =~ /\.xs\z/){
1454 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1457 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1459 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1460 } elsif ($name =~ /\.h\z/i){
1462 } elsif ($name =~ /\.PL\z/) {
1463 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1464 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1465 # case-insensitive filesystem, one dot per name, so foo.h.PL
1466 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1467 local($/); open(PL,$name); my $txt = <PL>; close PL;
1468 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1469 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1472 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1474 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1475 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1479 # Some larger extensions often wish to install a number of *.pm/pl
1480 # files into the library in various locations.
1482 # The attribute PMLIBDIRS holds an array reference which lists
1483 # subdirectories which we should search for library files to
1484 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1485 # recursively search through the named directories (skipping any
1486 # which don't exist or contain Makefile.PL files).
1488 # For each *.pm or *.pl file found $self->libscan() is called with
1489 # the default installation path in $_[1]. The return value of
1490 # libscan defines the actual installation location. The default
1491 # libscan function simply returns the path. The file is skipped
1492 # if libscan returns false.
1494 # The default installation location passed to libscan in $_[1] is:
1496 # ./*.pm => $(INST_LIBDIR)/*.pm
1497 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1498 # ./lib/... => $(INST_LIB)/...
1500 # In this way the 'lib' directory is seen as the root of the actual
1501 # perl library whereas the others are relative to INST_LIBDIR
1502 # (which includes PARENT_NAME). This is a subtle distinction but one
1503 # that's important for nested modules.
1505 unless( $self->{PMLIBDIRS} ) {
1507 # Avoid logical name vs directory collisions
1508 $self->{PMLIBDIRS} = ['./lib', "./$self->{BASEEXT}"];
1511 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}];
1515 #only existing directories that aren't in $dir are allowed
1517 # Avoid $_ wherever possible:
1518 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1519 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1521 @{$self->{PMLIBDIRS}} = ();
1522 foreach $pmlibdir (@pmlibdirs) {
1523 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1526 if (@{$self->{PMLIBDIRS}}){
1527 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1530 File::Find::find(sub {
1532 unless ($self->libscan($_)){
1533 $File::Find::prune = 1;
1538 return if /~$/; # emacs temp files
1539 return if /,v$/; # RCS files
1541 my $path = $File::Find::name;
1542 my $prefix = $self->{INST_LIBDIR};
1545 $prefix = $self->{INST_LIB}
1546 if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1548 my($inst) = $self->catfile($prefix,$striplibpath);
1549 local($_) = $inst; # for backwards compatibility
1550 $inst = $self->libscan($inst);
1551 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1552 return unless $inst;
1554 }, @{$self->{PMLIBDIRS}});
1557 $self->{PM} ||= \%pm;
1558 $self->{PL_FILES} ||= \%pl_files;
1560 $self->{DIR} ||= [sort keys %dir];
1562 $self->{XS} ||= \%xs;
1563 $self->{C} ||= [sort keys %c];
1564 my @o_files = @{$self->{C}};
1565 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files];
1567 $self->{H} ||= [sort keys %h];
1569 # Set up names of manual pages to generate from pods
1571 foreach my $man (qw(MAN1 MAN3)) {
1572 unless ($self->{"${man}PODS"}) {
1573 $self->{"${man}PODS"} = {};
1574 $pods{$man} = 1 unless
1575 $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/;
1580 if ( exists $self->{EXE_FILES} ) {
1581 foreach $name (@{$self->{EXE_FILES}}) {
1584 if (open(FH,"<$name")) {
1586 if (/^=(?:head\d+|item|pod)\b/) {
1593 # If it doesn't exist yet, we assume, it has pods in it
1598 $self->{MAN1PODS}->{$name} =
1599 $self->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1605 my %manifypods = (); # we collect the keys first, i.e. the files
1606 # we have to convert to pod
1607 foreach $name (keys %{$self->{PM}}) {
1608 if ($name =~ /\.pod\z/ ) {
1609 $manifypods{$name} = $self->{PM}{$name};
1610 } elsif ($name =~ /\.p[ml]\z/ ) {
1613 if (open(FH,"<$name")) {
1615 if (/^=head1\s+\w+/) {
1625 $manifypods{$name} = $self->{PM}{$name};
1630 # Remove "Configure.pm" and similar, if it's not the only pod listed
1631 # To force inclusion, just name it "Configure.pod", or override
1633 foreach $name (keys %manifypods) {
1634 if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) {
1635 delete $manifypods{$name};
1638 my($manpagename) = $name;
1639 $manpagename =~ s/\.p(od|m|l)\z//;
1640 # everything below lib is ok
1641 unless($manpagename =~ s!^\W*lib\W+!!s) {
1642 $manpagename = $self->catfile(
1643 split(/::/,$self->{PARENT_NAME}),$manpagename
1647 $manpagename = $self->replace_manpage_separator($manpagename);
1648 $self->{MAN3PODS}->{$name} =
1649 $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1655 =item init_DIRFILESEP
1657 Using / for Unix. Called by init_main.
1661 sub init_DIRFILESEP {
1664 $self->{DIRFILESEP} = '/';
1670 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1671 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1672 INSTALL*, INSTALLDIRS, LD, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1673 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1674 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1675 VERSION_SYM, XS_VERSION.
1682 # --- Initialize Module Name and Paths
1684 # NAME = Foo::Bar::Oracle
1685 # FULLEXT = Foo/Bar/Oracle
1687 # PARENT_NAME = Foo::Bar
1689 ### ($self->{FULLEXT} =
1690 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1691 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1694 # Copied from DynaLoader:
1696 my(@modparts) = split(/::/,$self->{NAME});
1697 my($modfname) = $modparts[-1];
1699 # Some systems have restrictions on files names for DLL's etc.
1700 # mod2fname returns appropriate file base name (typically truncated)
1701 # It may also edit @modparts if required.
1702 if (defined &DynaLoader::mod2fname) {
1703 $modfname = &DynaLoader::mod2fname(\@modparts);
1706 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1707 $self->{PARENT_NAME} ||= '';
1709 if (defined &DynaLoader::mod2fname) {
1710 # As of 5.001m, dl_os2 appends '_'
1711 $self->{DLBASE} = $modfname;
1713 $self->{DLBASE} = '$(BASEEXT)';
1717 # --- Initialize PERL_LIB, PERL_SRC
1719 # *Real* information: where did we get these two from? ...
1720 my $inc_config_dir = dirname($INC{'Config.pm'});
1721 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1723 unless ($self->{PERL_SRC}){
1725 foreach $dir ($Updir,
1726 $self->catdir($Updir,$Updir),
1727 $self->catdir($Updir,$Updir,$Updir),
1728 $self->catdir($Updir,$Updir,$Updir,$Updir),
1729 $self->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1732 -f $self->catfile($dir,"config_h.SH")
1734 -f $self->catfile($dir,"perl.h")
1736 -f $self->catfile($dir,"lib","Exporter.pm")
1738 $self->{PERL_SRC}=$dir ;
1744 warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1745 $self->{PERL_CORE} and !$self->{PERL_SRC};
1747 if ($self->{PERL_SRC}){
1748 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1750 if (defined $Cross::platform) {
1751 $self->{PERL_ARCHLIB} =
1752 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform);
1754 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform,
1755 $Is_Win32?("CORE"):());
1758 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1759 $self->{PERL_INC} = ($Is_Win32) ?
1760 $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1763 # catch a situation that has occurred a few times in the past:
1765 -s $self->catfile($self->{PERL_SRC},'cflags')
1769 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1776 You cannot build extensions below the perl source tree after executing
1777 a 'make clean' in the perl source tree.
1779 To rebuild extensions distributed with the perl source you should
1780 simply Configure (to include those extensions) and then build perl as
1781 normal. After installing perl the source tree can be deleted. It is
1782 not needed for building extensions by running 'perl Makefile.PL'
1783 usually without extra arguments.
1785 It is recommended that you unpack and build additional extensions away
1786 from the perl source tree.
1790 # we should also consider $ENV{PERL5LIB} here
1791 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1792 $self->{PERL_LIB} ||= $Config{privlibexp};
1793 $self->{PERL_ARCHLIB} ||= $Config{archlibexp};
1794 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1797 if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
1799 # Maybe somebody tries to build an extension with an
1800 # uninstalled Perl outside of Perl build tree
1802 for my $dir (@INC) {
1803 $found = $dir, last if -e $self->catdir($dir, "Config.pm");
1806 my $inc = dirname $found;
1807 if (-e $self->catdir($inc, "perl.h")) {
1808 $self->{PERL_LIB} = $found;
1809 $self->{PERL_ARCHLIB} = $found;
1810 $self->{PERL_INC} = $inc;
1811 $self->{UNINSTALLED_PERL} = 1;
1813 ... Detected uninstalled Perl. Trying to continue.
1819 unless(-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h")))
1822 Error: Unable to locate installed Perl libraries or Perl source code.
1824 It is recommended that you install perl in a standard location before
1825 building extensions. Some precompiled versions of perl do not contain
1826 these header files, so you cannot build extensions. In such a case,
1827 please build and install your perl from a fresh perl distribution. It
1828 usually solves this kind of problem.
1830 \(You get this message, because MakeMaker could not find "$perl_h"\)
1833 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1834 # if $Verbose && $self->needs_linking();
1838 # We get SITELIBEXP and SITEARCHEXP directly via
1839 # Get_from_Config. When we are running standard modules, these
1840 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1841 # set it to "site". I prefer that INSTALLDIRS be set from outside
1843 $self->{INSTALLDIRS} ||= "site";
1845 $self->{MAN1EXT} ||= $Config{man1ext};
1846 $self->{MAN3EXT} ||= $Config{man3ext};
1848 # Get some stuff out of %Config if we haven't yet done so
1849 print STDOUT "CONFIG must be an array ref\n"
1850 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1851 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1852 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1853 push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1855 foreach my $m (@{$self->{CONFIG}}){
1856 next if $once_only{$m};
1857 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1858 unless exists $Config{$m};
1859 $self->{uc $m} ||= $Config{$m};
1863 # This is too dangerous:
1864 # if ($^O eq "next") {
1865 # $self->{AR} = "libtool";
1866 # $self->{AR_STATIC_ARGS} = "-o";
1868 # But I leave it as a placeholder
1870 $self->{AR_STATIC_ARGS} ||= "cr";
1872 # These should never be needed
1873 $self->{LD} ||= 'ld';
1874 $self->{OBJ_EXT} ||= '.o';
1875 $self->{LIB_EXT} ||= '.a';
1877 $self->{MAP_TARGET} ||= "perl";
1879 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1881 # make a simple check if we find Exporter
1882 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1883 (Exporter.pm not found)"
1884 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1885 $self->{NAME} eq "ExtUtils::MakeMaker";
1890 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1891 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, SHELL, NOOP,
1892 FIRST_MAKEFILE, MAKEFILE_OLD, NOECHO, RM_F, RM_RF, TEST_F,
1893 TOUCH, CP, MV, CHMOD, UMASK_NULL, ECHO, ECHO_N
1897 sub init_others { # --- Initialize Other Attributes
1900 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1901 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1902 # undefined. In any case we turn it into an anon array:
1904 # May check $Config{libs} too, thus not empty.
1905 $self->{LIBS} = [$self->{LIBS}] unless ref $self->{LIBS};
1907 $self->{LIBS} = [''] unless @{$self->{LIBS}} && defined $self->{LIBS}[0];
1908 $self->{LD_RUN_PATH} = "";
1910 foreach $libs ( @{$self->{LIBS}} ){
1911 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1912 my(@libs) = $self->extliblist($libs);
1913 if ($libs[0] or $libs[1] or $libs[2]){
1914 # LD_RUN_PATH now computed by ExtUtils::Liblist
1915 ($self->{EXTRALIBS}, $self->{BSLOADLIBS},
1916 $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1921 if ( $self->{OBJECT} ) {
1922 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1924 # init_dirscan should have found out, if we have C files
1925 $self->{OBJECT} = "";
1926 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1928 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1929 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1930 $self->{PERLMAINCC} ||= '$(CC)';
1931 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1933 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1934 # the 'dynamic' section of MM. We don't have this problem with
1935 # 'static', since we either must use it (%Config says we can't
1936 # use dynamic loading) or the caller asked for it explicitly.
1937 if (!$self->{LINKTYPE}) {
1938 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1940 : ($Config{usedl} ? 'dynamic' : 'static');
1943 $self->{NOOP} ||= '$(SHELL) -c true';
1944 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1946 $self->{MAKEFILE} ||= 'Makefile';
1947 $self->{FIRST_MAKEFILE} ||= $self->{MAKEFILE};
1948 $self->{MAKEFILE_OLD} ||= '$(FIRST_MAKEFILE).old';
1949 $self->{MAKE_APERL_FILE} ||= '$(FIRST_MAKEFILE).aperl';
1951 $self->{SHELL} ||= $Config{sh} || '/bin/sh';
1953 $self->{ECHO} ||= 'echo';
1954 $self->{ECHO_N} ||= 'echo -n';
1955 $self->{RM_F} ||= "rm -f";
1956 $self->{RM_RF} ||= "rm -rf";
1957 $self->{TOUCH} ||= "touch";
1958 $self->{TEST_F} ||= "test -f";
1959 $self->{CP} ||= "cp";
1960 $self->{MV} ||= "mv";
1961 $self->{CHMOD} ||= "chmod";
1962 $self->{MKPATH} ||= '$(PERLRUN) "-MExtUtils::Command" -e mkpath';
1963 $self->{EQUALIZE_TIMESTAMP} ||=
1964 '$(PERLRUN) "-MExtUtils::Command" -e eqtime';
1966 $self->{UNINST} ||= 0;
1967 $self->{VERBINST} ||= 0;
1968 $self->{MOD_INSTALL} ||=
1969 $self->oneliner(<<'CODE', ['-MExtUtils::Install']);
1970 install({@ARGV}, '$(VERBINST)', 0, '$(UNINST)');
1972 $self->{DOC_INSTALL} ||=
1973 '$(PERLRUN) "-MExtUtils::Command::MM" -e perllocal_install';
1974 $self->{UNINSTALL} ||=
1975 '$(PERLRUN) "-MExtUtils::Command::MM" -e uninstall';
1976 $self->{WARN_IF_OLD_PACKLIST} ||=
1977 '$(PERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist';
1979 $self->{UMASK_NULL} ||= "umask 0";
1980 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1989 Called by init_main. Sets up all INST_* variables except those related
1990 to XS code. Those are handled in init_xs.
1997 $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
1998 $self->{INST_BIN} ||= $self->catdir($Curdir,'blib','bin');
2000 # INST_LIB typically pre-set if building an extension after
2001 # perl has been built and installed. Setting INST_LIB allows
2002 # you to build directly into, say $Config{privlibexp}.
2003 unless ($self->{INST_LIB}){
2004 if ($self->{PERL_CORE}) {
2005 if (defined $Cross::platform) {
2006 $self->{INST_LIB} = $self->{INST_ARCHLIB} =
2007 $self->catdir($self->{PERL_LIB},"..","xlib",
2011 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
2014 $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
2018 my @parentdir = split(/::/, $self->{PARENT_NAME});
2019 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)', @parentdir);
2020 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)', @parentdir);
2021 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)', 'auto',
2023 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
2026 $self->{INST_SCRIPT} ||= $self->catdir($Curdir,'blib','script');
2028 $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
2029 $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
2038 Called by init_main. Sets up all INSTALL_* variables (except
2039 INSTALLDIRS) and *PREFIX.
2046 $self->init_lib2arch;
2048 # Initialize installvendorman*dir if necessary
2049 foreach my $num (1, 3) {
2050 my $k = 'installvendorman'.$num.'dir';
2052 unless ($Config{$k}) {
2053 $Config_Override{$k} = $Config{usevendorprefix} ?
2054 $self->catdir($Config{vendorprefixexp}, 'man', "man$num") :
2059 my $iprefix = $Config{installprefixexp} || $Config{installprefix} ||
2060 $Config{prefixexp} || $Config{prefix} || '';
2061 my $vprefix = $Config{usevendorprefix} ? $Config{vendorprefixexp} : '';
2062 my $sprefix = $Config{siteprefixexp} || '';
2064 # 5.005_03 doesn't have a siteprefix.
2065 $sprefix = $iprefix unless $sprefix;
2067 # There are often no Config.pm defaults for these, but we can make
2069 unless( $Config{installsiteman1dir} ) {
2070 $Config_Override{installsiteman1dir} =
2071 $self->catdir($sprefix, 'man', 'man1');
2074 unless( $Config{installsiteman3dir} ) {
2075 $Config_Override{installsiteman3dir} =
2076 $self->catdir($sprefix, 'man', 'man3');
2079 unless( $Config{installsitebin} ) {
2080 $Config_Override{installsitebin} =
2081 $self->catdir($sprefix, 'bin');
2084 $self->{PREFIX} ||= '';
2086 if( $self->{PREFIX} ) {
2087 @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
2091 $self->{PERLPREFIX} ||= $iprefix;
2092 $self->{SITEPREFIX} ||= $sprefix;
2093 $self->{VENDORPREFIX} ||= $vprefix;
2096 my $arch = $Config{archname};
2097 my $version = $Config{version};
2100 my $libstyle = $Config{installstyle} || 'lib/perl5';
2103 if( $self->{LIBSTYLE} ) {
2104 $libstyle = $self->{LIBSTYLE};
2105 $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
2108 # Some systems, like VOS, set installman*dir to '' if they can't
2110 for my $num (1, 3) {
2111 $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
2112 unless $Config{'installman'.$num.'dir'};
2117 bin => { s => $iprefix,
2120 vendorbin => { s => $vprefix,
2123 sitebin => { s => $sprefix,
2126 script => { s => $iprefix,
2133 man1dir => { s => $iprefix,
2136 style => $manstyle, },
2137 siteman1dir => { s => $sprefix,
2140 style => $manstyle, },
2141 vendorman1dir => { s => $vprefix,
2144 style => $manstyle, },
2146 man3dir => { s => $iprefix,
2149 style => $manstyle, },
2150 siteman3dir => { s => $sprefix,
2153 style => $manstyle, },
2154 vendorman3dir => { s => $vprefix,
2157 style => $manstyle, },
2162 privlib => { s => $iprefix,
2165 style => $libstyle, },
2166 vendorlib => { s => $vprefix,
2169 style => $libstyle, },
2170 sitelib => { s => $sprefix,
2173 style => $libstyle, },
2175 archlib => { s => $iprefix,
2177 d => "$version/$arch",
2178 style => $libstyle },
2179 vendorarch => { s => $vprefix,
2181 d => "$version/$arch",
2182 style => $libstyle },
2183 sitearch => { s => $sprefix,
2185 d => "site_perl/$version/$arch",
2186 style => $libstyle },
2190 # Special case for LIB.
2191 if( $self->{LIB} ) {
2192 foreach my $var (keys %lib_layouts) {
2193 my $Installvar = uc "install$var";
2195 if( $var =~ /arch/ ) {
2196 $self->{$Installvar} ||=
2197 $self->catdir($self->{LIB}, $Config{archname});
2200 $self->{$Installvar} ||= $self->{LIB};
2205 my %type2prefix = ( perl => 'PERLPREFIX',
2206 site => 'SITEPREFIX',
2207 vendor => 'VENDORPREFIX'
2210 my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
2211 while( my($var, $layout) = each(%layouts) ) {
2212 my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
2213 my $r = '$('.$type2prefix{$t}.')';
2215 print STDERR "Prefixing $var\n" if $Verbose >= 2;
2217 my $installvar = "install$var";
2218 my $Installvar = uc $installvar;
2219 next if $self->{$Installvar};
2221 $d = "$style/$d" if $style;
2222 $self->prefixify($installvar, $s, $r, $d);
2224 print STDERR " $Installvar == $self->{$Installvar}\n"
2228 # Generate these if they weren't figured out.
2229 $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
2230 $self->{VENDORLIBEXP} ||= $self->{INSTALLVENDORLIB};
2237 Unix has no need of special linker flags.
2243 $self->{PERL_ARCHIVE} ||= '';
2244 $self->{PERL_ARCHIVE_AFTER} ||= '';
2245 $self->{EXPORT_LIST} ||= '';
2262 # The user who requests an installation directory explicitly
2263 # should not have to tell us an architecture installation directory
2264 # as well. We look if a directory exists that is named after the
2265 # architecture. If not we take it as a sign that it should be the
2266 # same as the requested installation directory. Otherwise we take
2268 for my $libpair ({l=>"privlib", a=>"archlib"},
2269 {l=>"sitelib", a=>"sitearch"},
2270 {l=>"vendorlib", a=>"vendorarch"},
2273 my $lib = "install$libpair->{l}";
2275 my $Arch = uc "install$libpair->{a}";
2276 if( $self->{$Lib} && ! $self->{$Arch} ){
2277 my($ilib) = $Config{$lib};
2279 $self->prefixify($Arch,$ilib,$self->{$Lib});
2281 unless (-d $self->{$Arch}) {
2282 print STDOUT "Directory $self->{$Arch} not found\n"
2284 $self->{$Arch} = $self->{$Lib};
2286 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
2296 Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the
2297 *PERLRUN* permutations.
2299 PERL is allowed to be miniperl
2300 FULLPERL must be a complete perl
2302 ABSPERL is PERL converted to an absolute path
2304 *PERLRUN contains everything necessary to run perl, find it's
2307 *PERLRUNINST is *PERLRUN + everything necessary to find the
2308 modules being built.
2316 foreach my $component ($self->{PERL_SRC}, $self->path(),
2319 push @defpath, $component if defined $component;
2322 # Build up a set of file names (not command names).
2323 my $thisperl = $self->canonpath($^X);
2324 $thisperl .= $Config{exe_ext} unless $thisperl =~ m/$Config{exe_ext}$/i;
2326 # We need a relative path to perl when in the core.
2327 $thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE};
2329 my @perls = ($thisperl);
2330 push @perls, map { "$_$Config{exe_ext}" }
2331 ('perl', 'perl5', "perl$Config{version}");
2333 # miniperl has priority over all but the cannonical perl when in the
2334 # core. Otherwise its a last resort.
2335 my $miniperl = "miniperl$Config{exe_ext}";
2336 if( $self->{PERL_CORE} ) {
2337 splice @perls, 1, 0, $miniperl;
2340 push @perls, $miniperl;
2344 $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
2345 # don't check if perl is executable, maybe they have decided to
2346 # supply switches with perl
2348 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2349 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
2350 unless $self->{FULLPERL};
2352 # Little hack to get around VMS's find_perl putting "MCR" in front
2354 $self->{ABSPERL} = $self->{PERL};
2355 my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2356 if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
2357 $self->{ABSPERL} = '$(PERL)';
2360 $self->{ABSPERL} = $self->rel2abs($self->{ABSPERL});
2361 $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2364 # Are we building the core?
2365 $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2367 # How do we run perl?
2368 foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2369 my $run = $perl.'RUN';
2371 $self->{$run} = "\$($perl)";
2373 # Make sure perl can find itself before it's installed.
2374 $self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
2375 if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2377 $self->{$perl.'RUNINST'} =
2378 sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2385 =item init_platform (o)
2387 Add MM_Unix_VERSION.
2389 =item platform_constants (o)
2396 $self->{MM_Unix_VERSION} = $VERSION;
2397 $self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '.
2398 '-Dfree=Perl_mfree -Drealloc=Perl_realloc '.
2399 '-Dcalloc=Perl_calloc';
2403 sub platform_constants {
2407 foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF))
2409 next unless defined $self->{$macro};
2410 $make_frag .= "$macro = $self->{$macro}\n";
2421 Called by init_main. Initializes PERL_*
2428 $self->{PERM_RW} = 644 unless defined $self->{PERM_RW};
2429 $self->{PERM_RWX} = 755 unless defined $self->{PERM_RWX};
2439 Sets up macros having to do with XS code. Currently just INST_STATIC,
2440 INST_DYNAMIC and INST_BOOT.
2447 if ($self->has_link_code()) {
2448 $self->{INST_STATIC} =
2449 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)');
2450 $self->{INST_DYNAMIC} =
2451 $self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)');
2452 $self->{INST_BOOT} =
2453 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs');
2455 $self->{INST_STATIC} = '';
2456 $self->{INST_DYNAMIC} = '';
2457 $self->{INST_BOOT} = '';
2463 Defines the install target.
2468 my($self, %attribs) = @_;
2472 install :: all pure_install doc_install
2474 install_perl :: all pure_perl_install doc_perl_install
2476 install_site :: all pure_site_install doc_site_install
2478 install_vendor :: all pure_vendor_install doc_vendor_install
2480 pure_install :: pure_$(INSTALLDIRS)_install
2482 doc_install :: doc_$(INSTALLDIRS)_install
2484 pure__install : pure_site_install
2485 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2487 doc__install : doc_site_install
2488 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2490 pure_perl_install ::
2491 $(NOECHO) $(MOD_INSTALL) \
2492 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2493 write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2494 $(INST_LIB) $(DESTINSTALLPRIVLIB) \
2495 $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
2496 $(INST_BIN) $(DESTINSTALLBIN) \
2497 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2498 $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
2499 $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
2500 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2501 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2504 pure_site_install ::
2505 $(NOECHO) $(MOD_INSTALL) \
2506 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2507 write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2508 $(INST_LIB) $(DESTINSTALLSITELIB) \
2509 $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
2510 $(INST_BIN) $(DESTINSTALLSITEBIN) \
2511 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2512 $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
2513 $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
2514 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2515 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2517 pure_vendor_install ::
2518 $(NOECHO) $(MOD_INSTALL) \
2519 read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2520 write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \
2521 $(INST_LIB) $(DESTINSTALLVENDORLIB) \
2522 $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
2523 $(INST_BIN) $(DESTINSTALLVENDORBIN) \
2524 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2525 $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
2526 $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
2529 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2530 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2531 -$(NOECHO) $(DOC_INSTALL) \
2532 "Module" "$(NAME)" \
2533 "installed into" "$(INSTALLPRIVLIB)" \
2534 LINKTYPE "$(LINKTYPE)" \
2535 VERSION "$(VERSION)" \
2536 EXE_FILES "$(EXE_FILES)" \
2537 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2540 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2541 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2542 -$(NOECHO) $(DOC_INSTALL) \
2543 "Module" "$(NAME)" \
2544 "installed into" "$(INSTALLSITELIB)" \
2545 LINKTYPE "$(LINKTYPE)" \
2546 VERSION "$(VERSION)" \
2547 EXE_FILES "$(EXE_FILES)" \
2548 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2550 doc_vendor_install ::
2551 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2552 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2553 -$(NOECHO) $(DOC_INSTALL) \
2554 "Module" "$(NAME)" \
2555 "installed into" "$(INSTALLVENDORLIB)" \
2556 LINKTYPE "$(LINKTYPE)" \
2557 VERSION "$(VERSION)" \
2558 EXE_FILES "$(EXE_FILES)" \
2559 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2564 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2566 uninstall_from_perldirs ::
2567 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2569 uninstall_from_sitedirs ::
2570 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2572 uninstall_from_vendordirs ::
2573 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2579 =item installbin (o)
2581 Defines targets to make and to install EXE_FILES.
2587 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2588 return "" unless @{$self->{EXE_FILES}};
2589 my(@m, $from, $to, %fromto, @to);
2590 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2591 for $from (@{$self->{EXE_FILES}}) {
2592 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2593 local($_) = $path; # for backwards compatibility
2594 $to = $self->libscan($path);
2595 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2598 @to = values %fromto;
2602 $fixin = $self->{PERL_CORE} ? '$(PERLRUN) ../../win32/bin/pl2bat.pl'
2606 $fixin = q{$(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"};
2610 EXE_FILES = @{$self->{EXE_FILES}}
2621 while (($from,$to) = each %fromto) {
2622 last unless defined $from;
2623 my $todir = dirname($to);
2625 $to: $from \$(FIRST_MAKEFILE) " . $self->catdir($todir,'.exists') . "
2626 \$(NOECHO) \$(RM_F) $to
2629 -\$(NOECHO) \$(CHMOD) \$(PERM_RWX) $to
2638 Defines the linkext target which in turn defines the LINKTYPE.
2643 my($self, %attribs) = @_;
2644 # LINKTYPE => static or dynamic or ''
2645 my($linktype) = defined $attribs{LINKTYPE} ?
2646 $attribs{LINKTYPE} : '$(LINKTYPE)';
2648 linkext :: $linktype
2655 Takes as arguments a directory name and a regular expression. Returns
2656 all entries in the directory that match the regular expression.
2662 my($dir, $regex) = @_;
2664 my $dh = new DirHandle;
2665 $dh->open($dir || ".") or return ();
2668 @ls = grep(/$regex/, @ls) if $regex;
2674 Simple subroutine to insert the macros defined by the macro attribute
2680 my($self,%attribs) = @_;
2682 while (($key,$val) = each %attribs){
2683 last unless defined $key;
2684 push @m, "$key = $val\n";
2691 Called by staticmake. Defines how to write the Makefile to produce a
2694 By default the Makefile produced includes all the static extensions in
2695 the perl library. (Purified versions of library files, e.g.,
2696 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2701 my($self, %attribs) = @_;
2702 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2703 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2706 # --- MakeMaker makeaperl section ---
2707 MAP_TARGET = $target
2708 FULLPERL = $self->{FULLPERL}
2710 return join '', @m if $self->{PARENT};
2712 my($dir) = join ":", @{$self->{DIR}};
2714 unless ($self->{MAKEAPERL}) {
2716 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2717 $(MAKE) -f $(MAKE_APERL_FILE) $@
2719 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2720 $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2721 $(NOECHO) $(PERLRUNINST) \
2722 Makefile.PL DIR=}, $dir, q{ \
2723 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2724 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2730 push @m, " \\\n\t\t$_";
2732 # push @m, map( " \\\n\t\t$_", @ARGV );
2740 my($cccmd, $linkcmd, $lperl);
2743 $cccmd = $self->const_cccmd($libperl);
2744 $cccmd =~ s/^CCCMD\s*=\s*//;
2745 $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2746 $cccmd .= " $Config{cccdlflags}"
2747 if ($Config{useshrplib} eq 'true');
2748 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2750 # The front matter of the linkcommand...
2751 $linkcmd = join ' ', "\$(CC)",
2752 grep($_, @Config{qw(ldflags ccdlflags)});
2753 $linkcmd =~ s/\s+/ /g;
2754 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2756 # Which *.a files could we make use of...
2759 File::Find::find(sub {
2760 return unless m/\Q$self->{LIB_EXT}\E$/;
2761 return if m/^libperl/;
2762 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2763 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2765 if( exists $self->{INCLUDE_EXT} ){
2770 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2774 # Throw away anything not explicitly marked for inclusion.
2775 # DynaLoader is implied.
2776 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2782 return unless $found;
2784 elsif( exists $self->{EXCLUDE_EXT} ){
2788 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2792 # Throw away anything explicitly marked for exclusion
2793 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2794 return if( $xx eq $excl );
2798 # don't include the installed version of this extension. I
2799 # leave this line here, although it is not necessary anymore:
2800 # I patched minimod.PL instead, so that Miniperl.pm won't
2801 # enclude duplicates
2803 # Once the patch to minimod.PL is in the distribution, I can
2805 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2807 $static{cwd() . "/" . $_}++;
2808 }, grep( -d $_, @{$searchdirs || []}) );
2810 # We trust that what has been handed in as argument, will be buildable
2811 $static = [] unless $static;
2812 @static{@{$static}} = (1) x @{$static};
2814 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2815 for (sort keys %static) {
2816 next unless /\Q$self->{LIB_EXT}\E\z/;
2817 $_ = dirname($_) . "/extralibs.ld";
2821 grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2826 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2827 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2828 # extralibs.all are computed correctly
2830 MAP_LINKCMD = $linkcmd
2831 MAP_PERLINC = @{$perlinc || []}
2833 join(" \\\n\t", reverse sort keys %static), "
2835 MAP_PRELIBS = $Config{perllibs} $Config{cryptlib}
2838 if (defined $libperl) {
2839 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2841 unless ($libperl && -f $lperl) { # Ilya's code...
2842 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2843 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2844 $libperl ||= "libperl$self->{LIB_EXT}";
2845 $libperl = "$dir/$libperl";
2846 $lperl ||= "libperl$self->{LIB_EXT}";
2847 $lperl = "$dir/$lperl";
2849 if (! -f $libperl and ! -f $lperl) {
2850 # We did not find a static libperl. Maybe there is a shared one?
2852 $lperl = $libperl = "$dir/$Config{libperl}";
2853 # SUNOS ld does not take the full path to a shared library
2854 $libperl = '' if $Is_SunOS4;
2858 print STDOUT "Warning: $libperl not found
2859 If you're going to build a static perl binary, make sure perl is installed
2860 otherwise ignore this warning\n"
2861 unless (-f $lperl || defined($self->{PERL_SRC}));
2864 # SUNOS ld does not take the full path to a shared library
2865 my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2868 MAP_LIBPERL = $libperl
2869 LLIBPERL = $llibperl
2873 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)\$(DIRFILESEP).exists ".join(" \\\n\t", @$extra).'
2874 $(NOECHO) $(RM_F) $@
2875 $(NOECHO) $(TOUCH) $@
2879 foreach $catfile (@$extra){
2880 push @m, "\tcat $catfile >> \$\@\n";
2884 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2885 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2886 \$(NOECHO) \$(ECHO) 'To install the new \"\$(MAP_TARGET)\" binary, call'
2887 \$(NOECHO) \$(ECHO) ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2888 \$(NOECHO) \$(ECHO) 'To remove the intermediate files say'
2889 \$(NOECHO) \$(ECHO) ' make -f $makefilename map_clean'
2891 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2893 push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2896 $tmp/perlmain.c: $makefilename}, q{
2897 $(NOECHO) $(ECHO) Writing $@
2898 $(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2899 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2902 push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain
2903 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2908 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2909 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2910 -$(NOECHO) $(DOC_INSTALL) \
2911 "Perl binary" "$(MAP_TARGET)" \
2912 MAP_STATIC "$(MAP_STATIC)" \
2913 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2914 MAP_LIBPERL "$(MAP_LIBPERL)" \
2915 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2920 inst_perl: pure_inst_perl doc_inst_perl
2922 pure_inst_perl: $(MAP_TARGET)
2923 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{
2928 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2936 Defines how to rewrite the Makefile.
2943 # We do not know what target was originally specified so we
2944 # must force a manual rerun to be sure. But as it should only
2945 # happen very rarely it is not a significant problem.
2947 $(OBJECT) : $(FIRST_MAKEFILE)
2948 ' if $self->{OBJECT};
2951 # We take a very conservative approach here, but it's worth it.
2952 # We move Makefile to Makefile.old here to avoid gnu make looping.
2953 $(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
2954 $(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?"
2955 $(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
2956 $(NOECHO) $(RM_F) $(MAKEFILE_OLD)
2957 $(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
2958 -$(MAKE) -f $(MAKEFILE_OLD) clean $(DEV_NULL) || $(NOOP)
2959 $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2960 $(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
2961 $(NOECHO) $(ECHO) "==> Please rerun the make command. <=="
2972 Returns true, if the argument is likely to be a command.
2977 my($self,$file) = @_;
2978 return $file if -x $file && ! -d $file;
2983 =item needs_linking (o)
2985 Does this module need linking? Looks into subdirectory objects (see
2986 also has_link_code())
2993 $caller = (caller(0))[3];
2994 confess("needs_linking called too early") if
2995 $caller =~ /^ExtUtils::MakeMaker::/;
2996 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2997 if ($self->has_link_code or $self->{MAKEAPERL}){
2998 $self->{NEEDS_LINKING} = 1;
3001 foreach $child (keys %{$self->{CHILDREN}}) {
3002 if ($self->{CHILDREN}->{$child}->needs_linking) {
3003 $self->{NEEDS_LINKING} = 1;
3007 return $self->{NEEDS_LINKING} = 0;
3012 misnamed method (will have to be changed). The MM_Unix method just
3013 returns the argument without further processing.
3015 On VMS used to insure that colons marking targets are preceded by
3016 space - most Unix Makes don't need this, but it's necessary under VMS
3017 to distinguish the target delimiter from a colon appearing as part of
3023 my($self,$text) = @_;
3027 =item parse_abstract
3029 parse a file and return what you think is the ABSTRACT
3033 sub parse_abstract {
3034 my($self,$parsefile) = @_;
3038 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3040 my $package = $self->{DISTNAME};
3041 $package =~ s/-/::/g;
3043 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3046 next unless /^($package\s-\s)(.*)/;
3056 parse a file and return what you think is $VERSION in this file set to.
3057 It will return the string "undef" if it can't figure out what $VERSION
3058 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
3059 are okay, but my $VERSION is not.
3064 my($self,$parsefile) = @_;
3068 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3071 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3072 next if $inpod || /^\s*#/;
3074 next unless /(?<!\\)([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
3076 package ExtUtils::MakeMaker::_version;
3085 $result = eval($eval);
3086 warn "Could not eval '$eval' in $parsefile: $@" if $@;
3091 $result = "undef" unless defined $result;
3098 Defines the string that is passed to recursive make calls in
3108 my($sep) = $Is_VMS ? ',' : '';
3111 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
3112 push @pasthru, "$key=\"\$($key)\"";
3115 foreach $key (qw(DEFINE INC)) {
3116 push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
3119 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
3125 Takes one argument, a file name, and returns the file name, if the
3126 argument is likely to be a perl script. On MM_Unix this is true for
3127 any ordinary, readable file.
3132 my($self,$file) = @_;
3133 return $file if -r $file && -f _;
3137 =item perldepend (o)
3139 Defines the dependency from all *.h files that come with the perl
3148 # Check for unpropogated config.sh changes. Should never happen.
3149 # We do NOT just update config.h because that is not sufficient.
3150 # An out of date config.h is not fatal but complains loudly!
3151 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
3152 -$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
3154 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
3155 $(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
3156 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
3157 } if $self->{PERL_SRC};
3159 return join "", @m unless $self->needs_linking;
3163 $(PERL_INC)/EXTERN.h \
3164 $(PERL_INC)/INTERN.h \
3165 $(PERL_INC)/XSUB.h \
3167 $(PERL_INC)/cc_runtime.h \
3168 $(PERL_INC)/config.h \
3171 $(PERL_INC)/dosish.h \
3172 $(PERL_INC)/embed.h \
3173 $(PERL_INC)/embedvar.h \
3174 $(PERL_INC)/fakethr.h \
3175 $(PERL_INC)/form.h \
3177 $(PERL_INC)/handy.h \
3179 $(PERL_INC)/intrpvar.h \
3180 $(PERL_INC)/iperlsys.h \
3181 $(PERL_INC)/keywords.h \
3183 $(PERL_INC)/nostdio.h \
3185 $(PERL_INC)/opcode.h \
3186 $(PERL_INC)/patchlevel.h \
3187 $(PERL_INC)/perl.h \
3188 $(PERL_INC)/perlio.h \
3189 $(PERL_INC)/perlsdio.h \
3190 $(PERL_INC)/perlsfio.h \
3191 $(PERL_INC)/perlvars.h \
3192 $(PERL_INC)/perly.h \
3194 $(PERL_INC)/pp_proto.h \
3195 $(PERL_INC)/proto.h \
3196 $(PERL_INC)/regcomp.h \
3197 $(PERL_INC)/regexp.h \
3198 $(PERL_INC)/regnodes.h \
3199 $(PERL_INC)/scope.h \
3201 $(PERL_INC)/thrdvar.h \
3202 $(PERL_INC)/thread.h \
3203 $(PERL_INC)/unixish.h \
3206 $(OBJECT) : $(PERL_HDRS)
3207 } if $self->{OBJECT};
3209 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
3217 Returns the attribute C<PERM_RW> or the string C<644>.
3218 Used as the string that is passed
3219 to the C<chmod> command to set the permissions for read/writeable files.
3220 MakeMaker chooses C<644> because it has turned out in the past that
3221 relying on the umask provokes hard-to-track bug reports.
3222 When the return value is used by the perl function C<chmod>, it is
3223 interpreted as an octal value.
3228 return shift->{PERM_RW};
3233 Returns the attribute C<PERM_RWX> or the string C<755>,
3234 i.e. the string that is passed
3235 to the C<chmod> command to set the permissions for executable files.
3241 return shift->{PERM_RWX};
3246 Defines target that copies all files in the hash PM to their
3247 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3253 my($autodir) = $self->catdir('$(INST_LIB)','auto');
3255 pm_to_blib: $(TO_INST_PM)
3258 my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']);
3259 pm_to_blib({\@ARGV}, '$autodir', '\$(PM_FILTER)')
3262 my @cmds = $self->split_command($pm_to_blib, %{$self->{PM}});
3264 $r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds;
3265 $r .= q{ $(NOECHO) $(TOUCH) $@};
3270 =item post_constants (o)
3272 Returns an empty string per default. Dedicated to overrides from
3273 within Makefile.PL after all constants have been defined.
3281 =item post_initialize (o)
3283 Returns an empty string per default. Used in Makefile.PLs to add some
3284 chunk of text to the Makefile after the object is initialized.
3288 sub post_initialize {
3294 Returns an empty string. Can be used in Makefile.PLs to write some
3295 text to the Makefile at the end.
3305 Defines target that creates a PPD (Perl Package Description) file
3306 for a binary distribution.
3313 if ($self->{ABSTRACT_FROM}){
3314 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3315 carp "WARNING: Setting ABSTRACT via file ".
3316 "'$self->{ABSTRACT_FROM}' failed\n";
3319 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
3321 my $abstract = $self->{ABSTRACT} || '';
3322 $abstract =~ s/\n/\\n/sg;
3323 $abstract =~ s/</</g;
3324 $abstract =~ s/>/>/g;
3326 my $author = $self->{AUTHOR} || '';
3327 $author =~ s/</</g;
3328 $author =~ s/>/>/g;
3330 my $ppd_xml = sprintf <<'PPD_HTML', $pack_ver, $abstract, $author;
3331 <SOFTPKG NAME="$(DISTNAME)" VERSION="%s">
3332 <TITLE>$(DISTNAME)</TITLE>
3333 <ABSTRACT>%s</ABSTRACT>
3337 $ppd_xml .= " <IMPLEMENTATION>\n";
3338 foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3339 my $pre_req = $prereq;
3340 $pre_req =~ s/::/-/g;
3341 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
3343 $ppd_xml .= sprintf <<'PPD_OUT', $pre_req, $dep_ver;
3344 <DEPENDENCY NAME="%s" VERSION="%s" />
3349 $ppd_xml .= sprintf <<'PPD_OUT', $Config{archname};
3350 <OS NAME="$(OSNAME)" />
3351 <ARCHITECTURE NAME="%s" />
3354 if ($self->{PPM_INSTALL_SCRIPT}) {
3355 if ($self->{PPM_INSTALL_EXEC}) {
3356 $ppd_xml .= sprintf qq{ <INSTALL EXEC="%s">%s</INSTALL>\n},
3357 $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3360 $ppd_xml .= sprintf qq{ <INSTALL>%s</INSTALL>\n},
3361 $self->{PPM_INSTALL_SCRIPT};
3365 my ($bin_location) = $self->{BINARY_LOCATION} || '';
3366 $bin_location =~ s/\\/\\\\/g;
3368 $ppd_xml .= sprintf <<'PPD_XML', $bin_location;
3369 <CODEBASE HREF="%s" />
3374 my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd');
3376 return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds;
3377 # Creates a PPD (Perl Package Description) for a binary distribution.
3386 $MM->prefixify($var, $prefix, $new_prefix, $default);
3388 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3389 replace it's $prefix with a $new_prefix.
3391 Should the $prefix fail to match I<AND> a PREFIX was given as an
3392 argument to WriteMakefile() it will set it to the $new_prefix +
3393 $default. This is for systems whose file layouts don't neatly fit into
3394 our ideas of prefixes.
3396 This is for heuristics which attempt to create directory structures
3397 that mirror those of the installed perl.
3401 $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3403 this will attempt to remove '/usr' from the front of the
3404 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3405 if necessary) and replace it with '/home/foo'. If this fails it will
3406 simply use '/home/foo/man/man1'.
3411 my($self,$var,$sprefix,$rprefix,$default) = @_;
3413 my $path = $self->{uc $var} ||
3414 $Config_Override{lc $var} || $Config{lc $var} || '';
3416 $rprefix .= '/' if $sprefix =~ m|/$|;
3418 print STDERR " prefixify $var => $path\n" if $Verbose >= 2;
3419 print STDERR " from $sprefix to $rprefix\n" if $Verbose >= 2;
3421 if( $path !~ s{^\Q$sprefix\E\b}{$rprefix}s && $self->{ARGS}{PREFIX} ) {
3423 print STDERR " cannot prefix, using default.\n" if $Verbose >= 2;
3424 print STDERR " no default!\n" if !$default && $Verbose >= 2;
3426 $path = $self->catdir($rprefix, $default) if $default;
3429 print " now $path\n" if $Verbose >= 2;
3430 return $self->{uc $var} = $path;
3436 Defines targets to run *.PL files.
3442 return "" unless $self->{PL_FILES};
3444 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3445 my $list = ref($self->{PL_FILES}->{$plfile})
3446 ? $self->{PL_FILES}->{$plfile}
3447 : [$self->{PL_FILES}->{$plfile}];
3449 foreach $target (@$list) {
3455 \$(PERLRUNINST) $plfile $target
3464 Backslashes parentheses C<()> in command line arguments.
3465 Doesn't handle recursive Makefile C<$(...)> constructs,
3466 but handles simple ones.
3472 $arg =~ s/\$\((.+?)\)/\$\\\\($1\\\\)/g; # protect $(...)
3473 $arg =~ s/(?<!\\)([()])/\\$1/g; # quote unprotected
3474 $arg =~ s/\$\\\\\((.+?)\\\\\)/\$($1)/g; # unprotect $(...)
3480 Defines the realclean target.
3485 my($self, %attribs) = @_;
3489 # Delete temporary files (via clean) and also delete installed files
3490 realclean purge :: clean realclean_subdirs
3491 $(RM_RF) $(INST_AUTODIR) $(INST_ARCHAUTODIR)
3492 $(RM_RF) $(DISTVNAME)
3495 if( $self->has_link_code ){
3496 push(@m, " \$(RM_F) \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3497 push(@m, " \$(RM_F) \$(INST_STATIC)\n");
3500 my @files = values %{$self->{PM}};
3501 push @files, $attribs{FILES} if $attribs{FILES};
3502 push @files, '$(FIRST_MAKEFILE)', '$(MAKEFILE_OLD)';
3504 # Occasionally files are repeated several times from different sources
3505 { my(%f) = map { ($_,1) } @files; @files = keys %f; }
3507 # Issue a several little RM_F commands rather than risk creating a
3508 # very long command line (useful for extensions such as Encode
3509 # that have many files).
3511 foreach my $file (@files) {
3512 if (length($line) + length($file) > 200) {
3513 push @m, "\t\$(RM_F) $line\n";
3520 push @m, "\t\$(RM_F) $line\n" if $line;
3521 push(@m, "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
3527 =item realclean_subdirs_target
3529 my $make_frag = $MM->realclean_subdirs_target;
3531 Returns the realclean_subdirs target. This is used by the realclean
3532 target to call realclean on any subdirectories which contain Makefiles.
3536 sub realclean_subdirs_target {
3539 return <<'NOOP_FRAG' unless @{$self->{DIR}};
3544 my $rclean = "realclean_subdirs :\n";
3546 foreach my $dir (@{$self->{DIR}}){
3547 $rclean .= sprintf <<'RCLEAN', $dir, $dir;
3548 -cd %s && $(TEST_F) $(MAKEFILE_OLD) && $(MAKE) -f $(MAKEFILE_OLD) realclean
3549 -cd %s && $(TEST_F) $(FIRST_MAKEFILE) && $(MAKE) realclean
3558 =item replace_manpage_separator
3560 my $man_name = $MM->replace_manpage_separator($file_path);
3562 Takes the name of a package, which may be a nested package, in the
3563 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3564 safe for a man page file name. Returns the replacement.
3568 sub replace_manpage_separator {
3569 my($self,$man) = @_;
3581 my($self, $cmd, $switches) = @_;
3582 $switches = [] unless defined $switches;
3584 # Strip leading and trailing newlines
3588 my @cmds = split /\n/, $cmd;
3589 $cmd = join " \n\t-e ", map $self->quote_literal($_), @cmds;
3590 $cmd = $self->escape_newlines($cmd);
3592 $switches = join ' ', @$switches;
3594 return qq{\$(PERLRUN) $switches -e $cmd};
3603 my($self, $text) = @_;
3605 # I think all we have to quote is single quotes and I think
3606 # this is a safe way to do it.
3607 $text =~ s{'}{'\\''}g;
3613 =item escape_newlines
3617 sub escape_newlines {
3618 my($self, $text) = @_;
3620 $text =~ s{\n}{\\\n}g;
3628 Using POSIX::ARG_MAX. Otherwise falling back to 4096.
3635 if (!defined $self->{_MAX_EXEC_LEN}) {
3636 if (my $arg_max = eval { require POSIX; &POSIX::ARG_MAX }) {
3637 $self->{_MAX_EXEC_LEN} = $arg_max;
3639 else { # POSIX minimum exec size
3640 $self->{_MAX_EXEC_LEN} = 4096;
3644 return $self->{_MAX_EXEC_LEN};
3650 Defines the static target.
3655 # --- Static Loading Sections ---
3659 ## $(INST_PM) has been moved to the all: target.
3660 ## It remains here for awhile to allow for old usage: "make static"
3661 static :: $(FIRST_MAKEFILE) $(INST_STATIC)
3666 =item static_lib (o)
3668 Defines how to produce the *.a (or equivalent) files.
3674 return '' unless $self->has_link_code;
3679 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
3683 # If this extension has its own library (eg SDBM_File)
3684 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3685 push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB};
3686 $(CP) $(MYEXTLIB) $@
3690 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3691 # Prefer the absolute pathed ar if available so that PATH
3692 # doesn't confuse us. Perl itself is built with the full_ar.
3697 push @m, sprintf <<'MAKE_FRAG', $ar;
3698 $(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
3699 $(CHMOD) $(PERM_RWX) $@
3700 $(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3703 # Old mechanism - still available:
3704 push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
3705 $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3708 push @m, "\n", $self->dir_target('$(INST_ARCHAUTODIR)');
3712 =item staticmake (o)
3719 my($self, %attribs) = @_;
3722 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3724 # And as it's not yet built, we add the current extension
3725 # but only if it has some C code (or XS code, which implies C code)
3726 if (@{$self->{C}}) {
3727 @static = $self->catfile($self->{INST_ARCHLIB},
3730 "$self->{BASEEXT}$self->{LIB_EXT}"
3734 # Either we determine now, which libraries we will produce in the
3735 # subdirectories or we do it at runtime of the make.
3737 # We could ask all subdir objects, but I cannot imagine, why it
3738 # would be necessary.
3740 # Instead we determine all libraries for the new perl at
3742 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3744 $self->makeaperl(MAKE => $self->{MAKEFILE},
3745 DIRS => \@searchdirs,
3748 TARGET => $self->{MAP_TARGET},
3750 LIBPERL => $self->{LIBPERL_A}
3756 Helper subroutine for subdirs
3761 my($self, $subdir) = @_;
3762 return sprintf <<'EOT', $subdir;
3765 $(NOECHO)cd %s && $(MAKE) -f $(FIRST_MAKEFILE) all $(PASTHRU)
3771 Defines targets to process subdirectories.
3776 # --- Sub-directory Sections ---
3779 # This method provides a mechanism to automatically deal with
3780 # subdirectories containing further Makefile.PL scripts.
3781 # It calls the subdir_x() method for each subdirectory.
3782 foreach $dir (@{$self->{DIR}}){
3783 push(@m, $self->subdir_x($dir));
3784 #### print "Including $dir subdirectory\n";
3788 # The default clean, realclean and test targets in this Makefile
3789 # have automatically been given entries for each subdir.
3793 push(@m, "\n# none")
3800 Defines the test targets.
3805 # --- Test and Installation Sections ---
3807 my($self, %attribs) = @_;
3808 my $tests = $attribs{TESTS} || '';
3809 if (!$tests && -d 't') {
3810 $tests = $self->find_tests;
3812 # note: 'test.pl' name is also hardcoded in init_dirscan()
3816 TEST_TYPE=test_\$(LINKTYPE)
3821 testdb :: testdb_\$(LINKTYPE)
3823 test :: \$(TEST_TYPE)
3827 push(@m, map(qq{\t\$(NOECHO) \$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q{\$(MAKE) test \$(PASTHRU)}" \$(FIRST_MAKEFILE)\n}, @{$self->{DIR}}));
3830 push(@m, map("\t\$(NOECHO) cd $_ && \$(TEST_F) \$(FIRST_MAKEFILE) && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3833 push(@m, "\t\$(NOECHO) \$(ECHO) 'No tests defined for \$(NAME) extension.'\n")
3834 unless $tests or -f "test.pl" or @{$self->{DIR}};
3837 push(@m, "test_dynamic :: pure_all\n");
3838 push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3840 push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3844 push(@m, "testdb_dynamic :: pure_all\n");
3845 push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3849 # Occasionally we may face this degenerate target:
3850 push @m, "test_ : test_dynamic\n\n";
3852 if ($self->needs_linking()) {
3853 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3854 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3855 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3857 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3858 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3861 push @m, "test_static :: test_dynamic\n";
3862 push @m, "testdb_static :: testdb_dynamic\n";
3867 =item test_via_harness (override)
3869 For some reason which I forget, Unix machines like to have
3870 PERL_DL_NONLAZY set for tests.
3874 sub test_via_harness {
3875 my($self, $perl, $tests) = @_;
3876 return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3879 =item test_via_script (override)
3881 Again, the PERL_DL_NONLAZY thing.
3885 sub test_via_script {
3886 my($self, $perl, $script) = @_;
3887 return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3891 =item tools_other (o)
3893 my $make_frag = $MM->tools_other;
3895 Returns a make fragment containing definitions for:
3897 SHELL, CHMOD, CP, MV, NOOP, NOECHO, RM_F, RM_RF, TEST_F, TOUCH,
3898 DEV_NULL, UMASK_NULL, MKPATH, EQUALIZE_TIMESTAMP,
3899 WARN_IF_OLD_PACKLIST, UNINST, VERBINST, MOD_INSTALL, DOC_INSTALL and
3902 init_others() initializes all these values.
3910 for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH
3911 UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP
3914 MOD_INSTALL DOC_INSTALL UNINSTALL
3915 WARN_IF_OLD_PACKLIST
3918 next unless defined $self->{$tool};
3919 push @m, "$tool = $self->{$tool}\n";
3925 =item tool_xsubpp (o)
3927 Determines typemaps, xsubpp version, prototype behaviour.
3933 return "" unless $self->needs_linking;
3936 foreach my $dir (@INC) {
3937 $xsdir = $self->catdir($dir, 'ExtUtils');
3938 if( -r $self->catfile($xsdir, "xsubpp") ) {
3943 my $tmdir = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3944 my(@tmdeps) = $self->catfile($tmdir,'typemap');
3945 if( $self->{TYPEMAPS} ){
3947 foreach $typemap (@{$self->{TYPEMAPS}}){
3948 if( ! -f $typemap ){
3949 warn "Typemap $typemap not found.\n";
3952 push(@tmdeps, $typemap);
3956 push(@tmdeps, "typemap") if -f "typemap";
3957 my(@tmargs) = map("-typemap $_", @tmdeps);
3958 if( exists $self->{XSOPT} ){
3959 unshift( @tmargs, $self->{XSOPT} );
3963 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3967 XSUBPP = \$(XSUBPPDIR)/xsubpp
3968 XSPROTOARG = $self->{XSPROTOARG}
3969 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3970 XSUBPPARGS = @tmargs
3978 Build man pages, too
3985 return <<'MAKE_EXT';
3986 all :: pure_all manifypods
3991 =item top_targets (o)
3993 Defines the targets all, subdirs, config, and O_FILES
3998 # --- Target Sections ---
4003 push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'};
4006 pure_all :: config pm_to_blib subdirs linkext
4009 subdirs :: $(MYEXTLIB)
4012 config :: $(FIRST_MAKEFILE) $(INST_LIBDIR)$(DIRFILESEP).exists
4015 config :: $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
4018 config :: $(INST_AUTODIR)$(DIRFILESEP).exists
4022 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
4024 if (%{$self->{MAN1PODS}}) {
4026 config :: $(INST_MAN1DIR)$(DIRFILESEP).exists
4030 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
4032 if (%{$self->{MAN3PODS}}) {
4034 config :: $(INST_MAN3DIR)$(DIRFILESEP).exists
4038 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
4042 $(O_FILES): $(H_FILES)
4043 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
4047 perldoc ExtUtils::MakeMaker
4055 Obsolete, deprecated method. Not used since Version 5.21.
4060 # --- perllocal.pod section ---
4061 my($self,$what,$name,@attribs)=@_;
4062 my $time = localtime;
4063 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
4064 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
4065 print "\n\n=back\n\n";
4070 Defines the suffix rules to compile XS files to C.
4076 return '' unless $self->needs_linking();
4079 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4085 Defines the suffix rules to compile XS files to C++.
4091 return '' unless $self->needs_linking();
4094 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
4100 Defines suffix rules to go from XS to object files directly. This is
4101 only intended for broken make implementations.
4105 sub xs_o { # many makes are too dumb to use xs_c then c_o
4107 return '' unless $self->needs_linking();
4110 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4111 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
4122 L<ExtUtils::MakeMaker>