1 package ExtUtils::MM_Unix;
3 require 5.005_03; # Maybe further back, dunno
10 use File::Basename qw(basename dirname fileparse);
14 use vars qw($VERSION @ISA
15 $Is_Mac $Is_OS2 $Is_VMS $Is_Win32 $Is_Dos $Is_VOS $Is_NetWare
16 $Verbose %pm %static $Xsubpp_Version
20 use ExtUtils::MakeMaker qw($Verbose neatvalue);
24 require ExtUtils::MM_Any;
25 @ISA = qw(ExtUtils::MM_Any);
27 $Is_OS2 = $^O eq 'os2';
28 $Is_Mac = $^O eq 'MacOS';
29 $Is_Win32 = $^O eq 'MSWin32';
30 $Is_Dos = $^O eq 'dos';
31 $Is_VOS = $^O eq 'vos';
32 +$Is_NetWare = $Config{'osname'} eq 'NetWare'; # Config{'osname'} intentional
38 if ($Is_VMS = $^O eq 'VMS') {
39 require VMS::Filespec;
40 import VMS::Filespec qw( &vmsify );
45 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
49 C<require ExtUtils::MM_Unix;>
53 The methods provided by this package are designed to be used in
54 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
55 Makefile, it creates one or more objects that inherit their methods
56 from a package C<MM>. MM itself doesn't provide any methods, but it
57 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
58 specific packages take the responsibility for all the methods provided
59 by MM_Unix. We are trying to reduce the number of the necessary
60 overrides by defining rather primitive operations within
63 If you are going to write a platform specific MM package, please try
64 to limit the necessary overrides to primitive methods, and if it is not
65 possible to do so, let's work out how to achieve that gain.
67 If you are overriding any of these methods in your Makefile.PL (in the
68 MY class), please report that to the makemaker mailing list. We are
69 trying to minimize the necessary method overrides and switch to data
70 driven Makefile.PLs wherever possible. In the long run less methods
71 will be overridable via the MY class.
75 The following description of methods is still under
76 development. Please refer to the code for not suitably documented
77 sections and complain loudly to the makemaker mailing list.
79 Not all of the methods below are overridable in a
80 Makefile.PL. Overridable methods are marked as (o). All methods are
81 overridable by a platform specific MM_*.pm file (See
82 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
86 # So we don't have to keep calling the methods over and over again,
87 # we have these globals to cache the values. They have to be global
88 # else the SelfLoaded methods can't see them.
89 use vars qw($Curdir $Rootdir $Updir);
90 $Curdir = File::Spec->curdir;
91 $Rootdir = File::Spec->rootdir;
92 $Updir = File::Spec->updir;
133 sub maybe_command_in_dirs;
140 sub perl_archive_after;
152 sub replace_manpage_separator;
159 sub test_via_harness;
173 # SelfLoader not smart enough to avoid autoloading DESTROY
180 =head2 SelfLoaded methods
186 Defines the suffix rules to compile different flavors of C files to
192 # --- Translation Sections ---
195 return '' unless $self->needs_linking();
197 if (my $cpp = $Config{cpprun}) {
198 my $cpp_cmd = $self->const_cccmd;
199 $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/$cpp/;
202 '. $cpp_cmd . ' $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c > $*.i
207 $(CCCMD) -S $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
211 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
215 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.C
216 ' if !$Is_OS2 and !$Is_Win32 and !$Is_Dos; #Case-specific
219 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cpp
222 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cxx
225 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cc
232 Does very much the same as the cflags script in the perl
233 distribution. It doesn't return the whole compiler command line, but
234 initializes all of its parts. The const_cccmd method then actually
235 returns the definition of the CCCMD macro which uses these parts.
242 my($self,$libperl)=@_;
243 return $self->{CFLAGS} if $self->{CFLAGS};
244 return '' unless $self->needs_linking();
246 my($prog, $uc, $perltype, %cflags);
247 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
248 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
250 @cflags{qw(cc ccflags optimize shellflags)}
251 = @Config{qw(cc ccflags optimize shellflags)};
254 $cflags{shellflags} ||= '';
259 DE => '-DDEBUGGING -DEMBED',
260 M => '-DEMBED -DMULTIPLICITY',
261 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
264 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
267 $uc = ""; # avoid warning
269 $perltype = $map{$uc} ? $map{$uc} : "";
277 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
278 if ($prog = $Config{$name}) {
279 # Expand hints for this extension via the shell
280 print STDOUT "Processing $name hint:\n" if $Verbose;
281 my(@o)=`cc=\"$cflags{cc}\"
282 ccflags=\"$cflags{ccflags}\"
283 optimize=\"$cflags{optimize}\"
284 perltype=\"$cflags{perltype}\"
285 optdebug=\"$cflags{optdebug}\"
288 echo ccflags=\$ccflags
289 echo optimize=\$optimize
290 echo perltype=\$perltype
291 echo optdebug=\$optdebug
296 if ($line =~ /(.*?)=\s*(.*)\s*$/){
298 print STDOUT " $1 = $2\n" if $Verbose;
300 print STDOUT "Unrecognised result from hint: '$line'\n";
306 $cflags{optimize} = $optdebug;
309 for (qw(ccflags optimize perltype)) {
311 $cflags{$_} =~ s/^\s+//;
312 $cflags{$_} =~ s/\s+/ /g;
313 $cflags{$_} =~ s/\s+$//;
314 $self->{uc $_} ||= $cflags{$_};
317 if ($self->{POLLUTE}) {
318 $self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
322 if ($Config{usemymalloc} and not $Config{bincompat5005}
323 and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
324 and $self->{PERL_MALLOC_OK}) {
325 $pollute = '$(PERL_MALLOC_DEF)';
328 $self->{CCFLAGS} = quote_paren($self->{CCFLAGS});
329 $self->{OPTIMIZE} = quote_paren($self->{OPTIMIZE});
331 return $self->{CFLAGS} = qq{
332 CCFLAGS = $self->{CCFLAGS}
333 OPTIMIZE = $self->{OPTIMIZE}
334 PERLTYPE = $self->{PERLTYPE}
342 Defines the clean target.
347 # --- Cleanup and Distribution Sections ---
349 my($self, %attribs) = @_;
352 # Delete temporary files but do not touch installed files. We don\'t delete
353 # the Makefile here so a later make realclean still has a makefile to use.
357 # clean subdirectories first
358 for $dir (@{$self->{DIR}}) {
359 if ($Is_Win32 && Win32::IsWin95()) {
362 \$(TEST_F) $self->{MAKEFILE}
369 -cd $dir && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) clean
374 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
375 if ( $^O eq 'qnx' ) {
376 my @errfiles = @{$self->{C}};
380 push( @otherfiles, @errfiles, 'perlmain.err' );
382 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
383 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE)
384 $(INST_ARCHAUTODIR)/extralibs.all
385 perlmain.c tmon.out mon.out so_locations pm_to_blib
386 *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
387 $(BOOTSTRAP) $(BASEEXT).bso
388 $(BASEEXT).def lib$(BASEEXT).def
389 $(BASEEXT).exp $(BASEEXT).x
392 push(@otherfiles, qw[*.kp]);
395 push(@otherfiles, qw[core core.*perl.*.? *perl.core]);
398 push @m, "\t-$self->{RM_RF} @otherfiles\n";
399 # See realclean and ext/utils/make_ext for usage of Makefile.old
401 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
403 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
407 =item const_cccmd (o)
409 Returns the full compiler call for C programs and stores the
410 definition in CONST_CCCMD.
415 my($self,$libperl)=@_;
416 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
417 return '' unless $self->needs_linking();
418 return $self->{CONST_CCCMD} =
419 q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
420 $(CCFLAGS) $(OPTIMIZE) \\
421 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
422 $(XS_DEFINE_VERSION)};
425 =item const_config (o)
427 Defines a couple of constants in the Makefile that are imported from
433 # --- Constants Sections ---
437 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
438 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
440 foreach $m (@{$self->{CONFIG}}){
441 # SITE*EXP macros are defined in &constants; avoid duplicates here
442 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
443 $self->{uc $m} = quote_paren($self->{uc $m});
444 push @m, uc($m) , ' = ' , $self->{uc $m}, "\n";
450 =item const_loadlibs (o)
452 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
453 L<ExtUtils::Liblist> for details.
459 return "" unless $self->needs_linking;
462 # $self->{NAME} might depend on some other libraries:
463 # See ExtUtils::Liblist for details
468 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
470 next unless defined $self->{$tmp};
471 push @m, "$tmp = $self->{$tmp}\n";
478 Initializes lots of constants and .SUFFIXES and .PHONY
488 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
489 VERSION_SYM XS_VERSION
490 INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB
492 PREFIX SITEPREFIX VENDORPREFIX
493 INSTALLPRIVLIB INSTALLSITELIB INSTALLVENDORLIB
494 INSTALLARCHLIB INSTALLSITEARCH INSTALLVENDORARCH
495 INSTALLBIN INSTALLSITEBIN INSTALLVENDORBIN INSTALLSCRIPT
496 PERL_LIB PERL_ARCHLIB
497 SITELIBEXP SITEARCHEXP
499 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
500 PERL_INC PERL FULLPERL PERLRUN FULLPERLRUN PERLRUNINST
501 FULLPERLRUNINST ABSPERL ABSPERLRUN ABSPERLRUNINST
502 FULL_AR PERL_CORE NOOP NOECHO
506 next unless defined $self->{$tmp};
508 # pathnames can have sharp signs in them; escape them so
509 # make doesn't think it is a comment-start character.
510 $self->{$tmp} =~ s/#/\\#/g;
511 push @m, "$tmp = $self->{$tmp}\n";
515 VERSION_MACRO = VERSION
516 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
517 XS_VERSION_MACRO = XS_VERSION
518 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
519 PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc
523 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
524 MM_VERSION = $ExtUtils::MakeMaker::VERSION
528 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
529 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
530 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
531 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
535 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
536 LDFROM LINKTYPE PM_FILTER
539 next unless defined $self->{$tmp};
540 push @m, "$tmp = $self->{$tmp}\n";
544 # Handy lists of source code files:
545 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
546 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
547 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
548 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
549 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
550 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
555 INSTALLMAN1DIR INSTALLSITEMAN1DIR INSTALLVENDORMAN1DIR
557 INSTALLMAN3DIR INSTALLSITEMAN3DIR INSTALLVENDORMAN3DIR
560 next unless defined $self->{$tmp};
561 push @m, "$tmp = $self->{$tmp}\n";
569 my $method = lc($tmp);
570 # warn "self[$self] method[$method]";
571 push @m, "$tmp = ", $self->$method(), "\n";
575 .NO_CONFIG_REC: Makefile
576 } if $ENV{CLEARCASE_ROOT};
578 # why not q{} ? -- emacs
580 # work around a famous dec-osf make(1) feature(?):
583 .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc \$(OBJ_EXT)
585 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
586 # some make implementations will delete the Makefile when we rebuild it. Because
587 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
588 # does so. Our milage may vary.
589 # .PRECIOUS: Makefile # seems to be not necessary anymore
591 .PHONY: all config static dynamic test linkext manifest
593 # Where is the Config information that we are using/depend on
594 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
597 my @parentdir = split(/::/, $self->{PARENT_NAME});
599 # Where to put things:
600 INST_LIBDIR = }. File::Spec->catdir('$(INST_LIB)',@parentdir) .q{
601 INST_ARCHLIBDIR = }. File::Spec->catdir('$(INST_ARCHLIB)',@parentdir) .q{
603 INST_AUTODIR = }. File::Spec->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
604 INST_ARCHAUTODIR = }. File::Spec->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
607 if ($self->has_link_code()) {
609 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
610 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
611 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
621 $tmp = $self->export_list;
625 $tmp = $self->perl_archive;
629 $tmp = $self->perl_archive_after;
631 PERL_ARCHIVE_AFTER = $tmp
635 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
637 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
645 Same as macro for the depend attribute.
650 my($self,%attribs) = @_;
652 while (($key,$val) = each %attribs){
653 last unless defined $key;
654 push @m, "$key : $val\n";
661 Takes an array of directories that need to exist and returns a
662 Makefile entry for a .exists file in these directories. Returns
663 nothing, if the entry has already been processed. We're helpless
664 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
665 them get an entry, that's why we use "::".
670 # --- Make-Directories section (internal method) ---
671 # dir_target(@array) returns a Makefile entry for the file .exists in each
672 # named directory. Returns nothing, if the entry has already been processed.
673 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
674 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
675 # prerequisite, because there has to be one, something that doesn't change
678 my($self,@dirs) = @_;
679 my(@m,$dir,$targdir);
680 foreach $dir (@dirs) {
681 my($src) = File::Spec->catfile($self->{PERL_INC},'perl.h');
682 my($targ) = File::Spec->catfile($dir,'.exists');
683 # catfile may have adapted syntax of $dir to target OS, so...
684 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
685 ($targdir = $targ) =~ s:/?\.exists\z::;
687 else { # while elsewhere we expect to see the dir separator in $targ
688 $targdir = dirname($targ);
690 next if $self->{DIR_TARGET}{$self}{$targdir}++;
693 $self->{NOECHO}\$(MKPATH) $targdir
694 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
697 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $targdir
705 Defines a lot of macros for distribution support.
710 my($self, %attribs) = @_;
712 # VERSION should be sanitised before use as a file name
713 $attribs{VERSION} ||= '$(VERSION)';
714 $attribs{NAME} ||= '$(DISTNAME)';
715 $attribs{TAR} ||= 'tar';
716 $attribs{TARFLAGS} ||= 'cvf';
717 $attribs{ZIP} ||= 'zip';
718 $attribs{ZIPFLAGS} ||= '-r';
719 $attribs{COMPRESS} ||= 'gzip --best';
720 $attribs{SUFFIX} ||= '.gz';
721 $attribs{SHAR} ||= 'shar';
722 $attribs{PREOP} ||= "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
723 $attribs{POSTOP} ||= "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
724 $attribs{TO_UNIX} ||= "$self->{NOECHO}\$(NOOP)";
726 $attribs{CI} ||= 'ci -u';
727 $attribs{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q';
728 $attribs{DIST_CP} ||= 'best';
729 $attribs{DIST_DEFAULT} ||= 'tardist';
731 $attribs{DISTVNAME} ||= "$attribs{NAME}-$attribs{VERSION}";
733 # We've already printed out VERSION and NAME variables.
734 delete $attribs{VERSION};
735 delete $attribs{NAME};
738 while(my($var, $value) = each %attribs) {
739 $make .= "$var = $value\n";
745 =item dist_basics (o)
747 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
754 return <<'MAKE_FRAG';
755 distclean :: realclean distcheck
759 $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
762 $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
765 $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
767 veryclean : realclean
768 $(RM_F) *~ *.orig */*~ */*.orig
776 Defines a check in target for RCS.
785 $(PERLRUN) "-MExtUtils::Manifest=maniread" \\
786 -e "@all = keys %{ maniread() };" \\
787 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
788 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
795 Defines the targets dist, tardist, zipdist, uutardist, shdist
803 dist : $(DIST_DEFAULT)
804 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
805 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
807 tardist : $(DISTVNAME).tar$(SUFFIX)
809 zipdist : $(DISTVNAME).zip
811 $(DISTVNAME).tar$(SUFFIX) : distdir
814 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
815 $(RM_RF) $(DISTVNAME)
816 $(COMPRESS) $(DISTVNAME).tar
819 $(DISTVNAME).zip : distdir
821 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
822 $(RM_RF) $(DISTVNAME)
825 uutardist : $(DISTVNAME).tar$(SUFFIX)
826 uuencode $(DISTVNAME).tar$(SUFFIX) \\
827 $(DISTVNAME).tar$(SUFFIX) > \\
828 $(DISTVNAME).tar$(SUFFIX)_uu
832 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
833 $(RM_RF) $(DISTVNAME)
841 Defines the scratch directory target that will hold the distribution
842 before tar-ing (or shar-ing).
849 return <<'MAKE_FRAG';
851 $(RM_RF) $(DISTVNAME)
852 $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
853 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
861 Defines a target that produces the distribution in the
862 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
872 cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
873 cd $(DISTVNAME) && $(MAKE)
874 cd $(DISTVNAME) && $(MAKE) test
881 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
887 my($self,%attribs) = @_;
889 return '' unless ($^O eq 'aix' && $self->needs_linking() );
891 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
892 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
893 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
897 dynamic :: $self->{BASEEXT}.exp
899 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
902 static :: $self->{BASEEXT}.exp
904 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
907 $self->{BASEEXT}.exp: Makefile.PL
908 ",' $(PERLRUN) -e \'use ExtUtils::Mksymlists; \\
909 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
910 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
911 ', "DL_VARS" => ', neatvalue($vars), ');\'
919 Defines the dynamic target.
924 # --- Dynamic Loading Sections ---
928 ## $(INST_PM) has been moved to the all: target.
929 ## It remains here for awhile to allow for old usage: "make dynamic"
930 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
931 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
932 '.$self->{NOECHO}.'$(NOOP)
938 Defines targets for bootstrap files.
943 my($self, %attribs) = @_;
946 ' unless $self->has_link_code();
949 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
951 # As Mkbootstrap might not write a file (if none is required)
952 # we use touch to prevent make continually trying to remake it.
953 # The DynaLoader only reads a non-empty file.
954 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
955 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
956 '.$self->{NOECHO}.'$(PERLRUN) \
957 "-MExtUtils::Mkbootstrap" \
958 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
959 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
960 $(CHMOD) $(PERM_RW) $@
962 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
963 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
964 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
965 $(CHMOD) $(PERM_RW) $@
969 =item dynamic_lib (o)
971 Defines how to produce the *.so (or equivalent) files.
976 my($self, %attribs) = @_;
977 return '' unless $self->needs_linking(); #might be because of a subdir
979 return '' unless $self->has_link_code;
981 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
982 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
983 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
984 my($ldfrom) = '$(LDFROM)';
985 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
987 my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
989 # This section creates the dynamically loadable $(INST_DYNAMIC)
990 # from $(OBJECT) and possibly $(MYEXTLIB).
991 ARMAYBE = '.$armaybe.'
992 OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
993 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
995 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
997 if ($armaybe ne ':'){
998 $ldfrom = 'tmp$(LIB_EXT)';
999 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1000 push(@m,' $(RANLIB) '."$ldfrom\n");
1002 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1004 # The IRIX linker doesn't use LD_RUN_PATH
1005 my $ldrun = $^O eq 'irix' && $self->{LD_RUN_PATH} ?
1006 qq{-rpath "$self->{LD_RUN_PATH}"} : '';
1008 # For example in AIX the shared objects/libraries from previous builds
1009 # linger quite a while in the shared dynalinker cache even when nobody
1010 # is using them. This is painful if one for instance tries to restart
1011 # a failed build because the link command will fail unnecessarily 'cos
1012 # the shared object/library is 'busy'.
1013 push(@m,' $(RM_F) $@
1016 my $libs = $self->{LDLOADLIBS} || '';
1018 if ($^O eq 'netbsd') {
1019 # Use nothing on static perl platforms, and to the flags needed
1020 # to link against the shared libperl library on shared perl
1021 # platforms. We peek at lddlflags to see if we need -Wl,-R
1022 # or -R to add paths to the run-time library search path.
1023 if ($Config{'useshrplib'}) {
1024 if ($Config{'lddlflags'} =~ /-Wl,-R/) {
1025 $libs = '-L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -lperl';
1026 } elsif ($Config{'lddlflags'} =~ /-R/) {
1027 $libs = '-L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -lperl';
1033 ' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1034 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) '.$libs.' $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST)');
1036 $(CHMOD) $(PERM_RWX) $@
1039 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1045 Deprecated method. Use libscan instead.
1050 my($self,$path) = @_;
1056 Called by init_others, and calls ext ExtUtils::Liblist. See
1057 L<ExtUtils::Liblist> for details.
1062 my($self,$libs) = @_;
1063 require ExtUtils::Liblist;
1064 $self->ext($libs, $Verbose);
1069 Finds the executables PERL and FULLPERL
1074 my($self, $ver, $names, $dirs, $trace) = @_;
1077 print "Looking for perl $ver by these names:
1083 foreach $name (@$names){
1084 foreach $dir (@$dirs){
1085 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1087 if (File::Spec->file_name_is_absolute($name)) { # /foo/bar
1089 } elsif (File::Spec->canonpath($name) eq File::Spec->canonpath(basename($name))) { # foo
1090 $abs = File::Spec->catfile($dir, $name);
1092 $abs = File::Spec->canonpath(File::Spec->catfile($Curdir, $name));
1094 print "Checking $abs\n" if ($trace >= 2);
1095 next unless $self->maybe_command($abs);
1096 print "Executing $abs\n" if ($trace >= 2);
1097 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1098 if ($val =~ /VER_OK/) {
1099 print "Using PERL=$abs\n" if $trace;
1101 } elsif ($trace >= 2) {
1102 print "Result: `$val'\n";
1106 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1107 0; # false and not empty
1112 =head2 Methods to actually produce chunks of text for the Makefile
1114 The methods here are called for each MakeMaker object in the order
1115 specified by @ExtUtils::MakeMaker::MM_Sections.
1123 Inserts the sharpbang or equivalent magic number to a set of @files.
1127 sub fixin { # stolen from the pink Camel book, more or less
1128 my($self, @files) = @_;
1130 my($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
1131 for my $file (@files) {
1134 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1136 chomp(my $line = <FIXIN>);
1137 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1138 # Now figure out the interpreter name.
1139 my($cmd,$arg) = split ' ', $line, 2;
1142 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1144 if ($cmd eq "perl") {
1145 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1146 $interpreter = $Config{startperl};
1147 $interpreter =~ s,^\#!,,;
1149 $interpreter = $Config{perlpath};
1152 my(@absdirs) = reverse grep {File::Spec->file_name_is_absolute} File::Spec->path;
1155 foreach $dir (@absdirs) {
1156 if ($self->maybe_command($cmd)) {
1157 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1158 $interpreter = File::Spec->catfile($dir,$cmd);
1162 # Figure out how to invoke interpreter on this machine.
1166 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1167 # this is probably value-free on DOSISH platforms
1169 $shb .= "$Config{'sharpbang'}$interpreter";
1170 $shb .= ' ' . $arg if defined $arg;
1174 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1175 if 0; # not running under some shell
1176 } unless $Is_Win32; # this won't work on win32, so don't
1178 warn "Can't find $cmd in PATH, $file unchanged"
1183 unless ( open(FIXOUT,">$file.new") ) {
1184 warn "Can't create new $file: $!\n";
1187 my($dev,$ino,$mode) = stat FIXIN;
1189 # Print out the new #! line (or equivalent).
1192 print FIXOUT $shb, <FIXIN>;
1196 unless ( rename($file, "$file.bak") ) {
1197 warn "Can't rename $file to $file.bak: $!";
1200 unless ( rename("$file.new", $file) ) {
1201 warn "Can't rename $file.new to $file: $!";
1202 unless ( rename("$file.bak", $file) ) {
1203 warn "Can't rename $file.bak back to $file either: $!";
1204 warn "Leaving $file renamed as $file.bak\n";
1210 close(FIXIN) if fileno(FIXIN);
1211 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1223 '# Phony target to force checking subdirectories.
1225 '.$self->{NOECHO}.'$(NOOP)
1231 Guess the name of this package by examining the working directory's
1232 name. MakeMaker calls this only if the developer has not supplied a
1242 my $name = basename(cwd());
1243 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1244 # strip minus or underline
1245 # followed by a float or some such
1246 print "Warning: Guessing NAME [$name] from current directory name.\n";
1252 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1253 object that need a compiler. Does not descend into subdirectories as
1254 needs_linking() does.
1260 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1261 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1262 $self->{HAS_LINK_CODE} = 1;
1265 return $self->{HAS_LINK_CODE} = 0;
1271 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1275 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1277 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1278 local(%pm); #the sub in find() has to see this hash
1280 @ignore{qw(Makefile.PL test.pl t)} = (1,1,1);
1282 # ignore the distdir
1283 $Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1
1284 : $ignore{$self->{DISTVNAME}} = 1;
1286 @ignore{map lc, keys %ignore} = values %ignore if $Is_VMS;
1288 foreach $name ($self->lsdir($Curdir)){
1289 next if $name =~ /\#/;
1290 next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
1291 next unless $self->libscan($name);
1293 next if -l $name; # We do not support symlinks at all
1294 $dir{$name} = $name if (-f File::Spec->catfile($name,"Makefile.PL"));
1295 } elsif ($name =~ /\.xs\z/){
1296 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1299 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1301 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1302 } elsif ($name =~ /\.h\z/i){
1304 } elsif ($name =~ /\.PL\z/) {
1305 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1306 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1307 # case-insensitive filesystem, one dot per name, so foo.h.PL
1308 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1309 local($/); open(PL,$name); my $txt = <PL>; close PL;
1310 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1311 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1314 $pm{$name} = File::Spec->catfile($self->{INST_LIBDIR},$name);
1316 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1317 $pm{$name} = File::Spec->catfile($self->{INST_LIBDIR},$name);
1321 # Some larger extensions often wish to install a number of *.pm/pl
1322 # files into the library in various locations.
1324 # The attribute PMLIBDIRS holds an array reference which lists
1325 # subdirectories which we should search for library files to
1326 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1327 # recursively search through the named directories (skipping any
1328 # which don't exist or contain Makefile.PL files).
1330 # For each *.pm or *.pl file found $self->libscan() is called with
1331 # the default installation path in $_[1]. The return value of
1332 # libscan defines the actual installation location. The default
1333 # libscan function simply returns the path. The file is skipped
1334 # if libscan returns false.
1336 # The default installation location passed to libscan in $_[1] is:
1338 # ./*.pm => $(INST_LIBDIR)/*.pm
1339 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1340 # ./lib/... => $(INST_LIB)/...
1342 # In this way the 'lib' directory is seen as the root of the actual
1343 # perl library whereas the others are relative to INST_LIBDIR
1344 # (which includes PARENT_NAME). This is a subtle distinction but one
1345 # that's important for nested modules.
1347 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1348 unless $self->{PMLIBDIRS};
1350 #only existing directories that aren't in $dir are allowed
1352 # Avoid $_ wherever possible:
1353 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1354 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1356 @{$self->{PMLIBDIRS}} = ();
1357 foreach $pmlibdir (@pmlibdirs) {
1358 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1361 if (@{$self->{PMLIBDIRS}}){
1362 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1365 File::Find::find(sub {
1367 if ($_ eq "CVS" || $_ eq "RCS"){
1368 $File::Find::prune = 1;
1373 return if /~$/; # emacs temp files
1375 my $path = $File::Find::name;
1376 my $prefix = $self->{INST_LIBDIR};
1379 $prefix = $self->{INST_LIB}
1380 if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1382 my($inst) = File::Spec->catfile($prefix,$striplibpath);
1383 local($_) = $inst; # for backwards compatibility
1384 $inst = $self->libscan($inst);
1385 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1386 return unless $inst;
1388 }, @{$self->{PMLIBDIRS}});
1391 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1392 $self->{XS} = \%xs unless $self->{XS};
1393 $self->{PM} = \%pm unless $self->{PM};
1394 $self->{C} = [sort keys %c] unless $self->{C};
1395 my(@o_files) = @{$self->{C}};
1396 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files] ;
1397 $self->{H} = [sort keys %h] unless $self->{H};
1398 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1400 # Set up names of manual pages to generate from pods
1402 foreach my $man (qw(MAN1 MAN3)) {
1403 unless ($self->{"${man}PODS"}) {
1404 $self->{"${man}PODS"} = {};
1405 $pods{$man} = 1 unless
1406 $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/;
1411 if ( exists $self->{EXE_FILES} ) {
1412 foreach $name (@{$self->{EXE_FILES}}) {
1415 if (open(FH,"<$name")) {
1417 if (/^=head1\s+\w+/) {
1424 # If it doesn't exist yet, we assume, it has pods in it
1429 $self->{MAN1PODS}->{$name} =
1430 File::Spec->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1436 my %manifypods = (); # we collect the keys first, i.e. the files
1437 # we have to convert to pod
1438 foreach $name (keys %{$self->{PM}}) {
1439 if ($name =~ /\.pod\z/ ) {
1440 $manifypods{$name} = $self->{PM}{$name};
1441 } elsif ($name =~ /\.p[ml]\z/ ) {
1444 if (open(FH,"<$name")) {
1446 if (/^=head1\s+\w+/) {
1456 $manifypods{$name} = $self->{PM}{$name};
1461 # Remove "Configure.pm" and similar, if it's not the only pod listed
1462 # To force inclusion, just name it "Configure.pod", or override
1464 foreach $name (keys %manifypods) {
1465 if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) {
1466 delete $manifypods{$name};
1469 my($manpagename) = $name;
1470 $manpagename =~ s/\.p(od|m|l)\z//;
1471 unless ($manpagename =~ s!^\W*lib\W+!!s) { # everything below lib is ok
1472 $manpagename = File::Spec->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1475 $manpagename = $self->replace_manpage_separator($manpagename);
1476 $self->{MAN3PODS}->{$name} =
1477 File::Spec->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1485 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1486 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1487 INSTALL*, INSTALLDIRS, LD, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1488 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1489 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1490 VERSION_FROM, VERSION_SYM, XS_VERSION.
1497 # --- Initialize Module Name and Paths
1499 # NAME = Foo::Bar::Oracle
1500 # FULLEXT = Foo/Bar/Oracle
1502 # PARENT_NAME = Foo::Bar
1504 ### ($self->{FULLEXT} =
1505 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1506 $self->{FULLEXT} = File::Spec->catdir(split /::/, $self->{NAME});
1509 # Copied from DynaLoader:
1511 my(@modparts) = split(/::/,$self->{NAME});
1512 my($modfname) = $modparts[-1];
1514 # Some systems have restrictions on files names for DLL's etc.
1515 # mod2fname returns appropriate file base name (typically truncated)
1516 # It may also edit @modparts if required.
1517 if (defined &DynaLoader::mod2fname) {
1518 $modfname = &DynaLoader::mod2fname(\@modparts);
1521 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1522 $self->{PARENT_NAME} ||= '';
1524 if (defined &DynaLoader::mod2fname) {
1525 # As of 5.001m, dl_os2 appends '_'
1526 $self->{DLBASE} = $modfname;
1528 $self->{DLBASE} = '$(BASEEXT)';
1532 # --- Initialize PERL_LIB, PERL_SRC
1534 # *Real* information: where did we get these two from? ...
1535 my $inc_config_dir = dirname($INC{'Config.pm'});
1536 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1538 unless ($self->{PERL_SRC}){
1540 foreach $dir ($Updir,
1541 File::Spec->catdir($Updir,$Updir),
1542 File::Spec->catdir($Updir,$Updir,$Updir),
1543 File::Spec->catdir($Updir,$Updir,$Updir,$Updir),
1544 File::Spec->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1547 -f File::Spec->catfile($dir,"config_h.SH")
1549 -f File::Spec->catfile($dir,"perl.h")
1551 -f File::Spec->catfile($dir,"lib","Exporter.pm")
1553 $self->{PERL_SRC}=$dir ;
1559 warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1560 $self->{PERL_CORE} and !$self->{PERL_SRC};
1562 if ($self->{PERL_SRC}){
1563 $self->{PERL_LIB} ||= File::Spec->catdir("$self->{PERL_SRC}","lib");
1564 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1565 $self->{PERL_INC} = ($Is_Win32 || $Is_NetWare) ? File::Spec->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1567 # catch a situation that has occurred a few times in the past:
1569 -s File::Spec->catfile($self->{PERL_SRC},'cflags')
1573 -s File::Spec->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1582 You cannot build extensions below the perl source tree after executing
1583 a 'make clean' in the perl source tree.
1585 To rebuild extensions distributed with the perl source you should
1586 simply Configure (to include those extensions) and then build perl as
1587 normal. After installing perl the source tree can be deleted. It is
1588 not needed for building extensions by running 'perl Makefile.PL'
1589 usually without extra arguments.
1591 It is recommended that you unpack and build additional extensions away
1592 from the perl source tree.
1596 # we should also consider $ENV{PERL5LIB} here
1597 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1598 $self->{PERL_LIB} ||= $Config{privlibexp};
1599 $self->{PERL_ARCHLIB} ||= $Config{archlibexp};
1600 $self->{PERL_INC} = File::Spec->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1603 no warnings 'uninitialized' ;
1604 if (not -f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h"))
1606 # Maybe somebody tries to build an extension with an
1607 # uninstalled Perl outside of Perl build tree
1609 for my $dir (@INC) {
1610 $found = $dir, last if -e File::Spec->catdir($dir, "Config.pm");
1613 my $inc = dirname $found;
1614 if (-e File::Spec->catdir($inc, "perl.h")) {
1615 $self->{PERL_LIB} = $found;
1616 $self->{PERL_ARCHLIB} = $found;
1617 $self->{PERL_INC} = $inc;
1618 $self->{UNINSTALLED_PERL} = 1;
1620 ... Detected uninstalled Perl. Trying to continue.
1626 unless(-f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h")))
1629 Error: Unable to locate installed Perl libraries or Perl source code.
1631 It is recommended that you install perl in a standard location before
1632 building extensions. Some precompiled versions of perl do not contain
1633 these header files, so you cannot build extensions. In such a case,
1634 please build and install your perl from a fresh perl distribution. It
1635 usually solves this kind of problem.
1637 \(You get this message, because MakeMaker could not find "$perl_h"\)
1640 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1641 # if $Verbose && $self->needs_linking();
1645 # We get SITELIBEXP and SITEARCHEXP directly via
1646 # Get_from_Config. When we are running standard modules, these
1647 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1648 # set it to "site". I prefer that INSTALLDIRS be set from outside
1650 $self->{INSTALLDIRS} ||= "site";
1654 $self->init_INSTALL;
1656 $self->{MAN1EXT} ||= $Config{man1ext};
1657 $self->{MAN3EXT} ||= $Config{man3ext};
1659 # Get some stuff out of %Config if we haven't yet done so
1660 print STDOUT "CONFIG must be an array ref\n"
1661 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1662 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1663 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1664 push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1666 foreach $m (@{$self->{CONFIG}}){
1667 next if $once_only{$m};
1668 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1669 unless exists $Config{$m};
1670 $self->{uc $m} ||= $Config{$m};
1674 # This is too dangerous:
1675 # if ($^O eq "next") {
1676 # $self->{AR} = "libtool";
1677 # $self->{AR_STATIC_ARGS} = "-o";
1679 # But I leave it as a placeholder
1681 $self->{AR_STATIC_ARGS} ||= "cr";
1683 # These should never be needed
1684 $self->{LD} ||= 'ld';
1685 $self->{OBJ_EXT} ||= '.o';
1686 $self->{LIB_EXT} ||= '.a';
1688 $self->{MAP_TARGET} ||= "perl";
1690 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1692 # make a simple check if we find Exporter
1693 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1694 (Exporter.pm not found)"
1695 unless -f File::Spec->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1696 $self->{NAME} eq "ExtUtils::MakeMaker";
1698 # Determine VERSION and VERSION_FROM
1699 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1700 if ($self->{VERSION_FROM}){
1701 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1702 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1706 if ($self->{VERSION}) {
1707 $self->{VERSION} =~ s/^\s+//;
1708 $self->{VERSION} =~ s/\s+$//;
1711 $self->{VERSION} ||= "0.10";
1712 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1714 $self->{DISTVNAME} = "$self->{DISTNAME}-$self->{VERSION}";
1716 # Graham Barr and Paul Marquess had some ideas how to ensure
1717 # version compatibility between the *.pm file and the
1718 # corresponding *.xs file. The bottomline was, that we need an
1719 # XS_VERSION macro that defaults to VERSION:
1720 $self->{XS_VERSION} ||= $self->{VERSION};
1723 # --- Initialize Perl Binary Locations
1729 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1730 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1731 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1735 sub init_others { # --- Initialize Other Attributes
1738 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1739 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1740 # undefined. In any case we turn it into an anon array:
1742 # May check $Config{libs} too, thus not empty.
1743 $self->{LIBS}=[''] unless $self->{LIBS};
1745 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1746 $self->{LD_RUN_PATH} = "";
1748 foreach $libs ( @{$self->{LIBS}} ){
1749 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1750 my(@libs) = $self->extliblist($libs);
1751 if ($libs[0] or $libs[1] or $libs[2]){
1752 # LD_RUN_PATH now computed by ExtUtils::Liblist
1753 ($self->{EXTRALIBS}, $self->{BSLOADLIBS},
1754 $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1759 if ( $self->{OBJECT} ) {
1760 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1762 # init_dirscan should have found out, if we have C files
1763 $self->{OBJECT} = "";
1764 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1766 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1767 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1768 $self->{PERLMAINCC} ||= '$(CC)';
1769 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1771 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1772 # the 'dynamic' section of MM. We don't have this problem with
1773 # 'static', since we either must use it (%Config says we can't
1774 # use dynamic loading) or the caller asked for it explicitly.
1775 if (!$self->{LINKTYPE}) {
1776 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1778 : ($Config{usedl} ? 'dynamic' : 'static');
1781 # These get overridden for VMS and maybe some other systems
1782 $self->{NOOP} ||= '$(SHELL) -c true';
1783 $self->{FIRST_MAKEFILE} ||= "Makefile";
1784 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1785 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1786 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1787 $self->{RM_F} ||= "rm -f";
1788 $self->{RM_RF} ||= "rm -rf";
1789 $self->{TOUCH} ||= "touch";
1790 $self->{TEST_F} ||= "test -f";
1791 $self->{CP} ||= "cp";
1792 $self->{MV} ||= "mv";
1793 $self->{CHMOD} ||= "chmod";
1794 $self->{UMASK_NULL} ||= "umask 0";
1795 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1802 Called by init_main. Sets up all INST_* variables.
1809 $self->{INST_ARCHLIB} ||= File::Spec->catdir($Curdir,"blib","arch");
1810 $self->{INST_BIN} ||= File::Spec->catdir($Curdir,'blib','bin');
1812 # INST_LIB typically pre-set if building an extension after
1813 # perl has been built and installed. Setting INST_LIB allows
1814 # you to build directly into, say $Config{privlibexp}.
1815 unless ($self->{INST_LIB}){
1816 if ($self->{PERL_CORE}) {
1817 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1819 $self->{INST_LIB} = File::Spec->catdir($Curdir,"blib","lib");
1823 my @parentdir = split(/::/, $self->{PARENT_NAME});
1824 $self->{INST_LIBDIR} = File::Spec->catdir($self->{INST_LIB},@parentdir);
1825 $self->{INST_ARCHLIBDIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1827 $self->{INST_AUTODIR} = File::Spec->catdir($self->{INST_LIB},'auto',
1829 $self->{INST_ARCHAUTODIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1830 'auto',$self->{FULLEXT});
1832 $self->{INST_SCRIPT} ||= File::Spec->catdir($Curdir,'blib','script');
1834 $self->{INST_MAN1DIR} ||= File::Spec->catdir($Curdir,'blib','man1');
1835 $self->{INST_MAN3DIR} ||= File::Spec->catdir($Curdir,'blib','man3');
1844 Called by init_main. Sets up all INSTALL_* variables (except
1845 INSTALLDIRS) and PREFIX.
1852 # The user who requests an installation directory explicitly
1853 # should not have to tell us an architecture installation directory
1854 # as well. We look if a directory exists that is named after the
1855 # architecture. If not we take it as a sign that it should be the
1856 # same as the requested installation directory. Otherwise we take
1858 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1859 for my $libpair ({l=>"privlib", a=>"archlib"},
1860 {l=>"sitelib", a=>"sitearch"})
1862 my $lib = "install$libpair->{l}";
1864 my $Arch = uc "install$libpair->{a}";
1865 if( $self->{$Lib} && ! $self->{$Arch} ){
1866 my($ilib) = $Config{$lib};
1867 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1869 $self->prefixify($Arch,$ilib,$self->{$Lib});
1871 unless (-d $self->{$Arch}) {
1872 print STDOUT "Directory $self->{$Arch} not found\n"
1874 $self->{$Arch} = $self->{$Lib};
1876 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1880 # There are no Config.pm defaults for these.
1881 $Config_Override{installsiteman1dir} =
1882 "$Config{siteprefixexp}/man/man\$(MAN1EXT)";
1883 $Config_Override{installsiteman3dir} =
1884 "$Config{siteprefixexp}/man/man\$(MAN3EXT)";
1885 $Config_Override{installvendorman1dir} =
1886 "$Config{vendorprefixexp}/man/man\$(MAN1EXT)";
1887 $Config_Override{installvendorman3dir} =
1888 "$Config{vendorprefixexp}/man/man\$(MAN3EXT)";
1890 my $iprefix = $Config{installprefixexp} || '';
1891 my $vprefix = $Config{vendorprefixexp} || $iprefix;
1892 my $sprefix = $Config{siteprefixexp} || '';
1894 my $u_prefix = $self->{PREFIX} || '';
1895 my $u_sprefix = $self->{SITEPREFIX} || $u_prefix;
1896 my $u_vprefix = $self->{VENDORPREFIX} || $u_prefix;
1898 $self->{PREFIX} ||= $u_prefix || $iprefix;
1899 $self->{SITEPREFIX} ||= $u_sprefix || $sprefix;
1900 $self->{VENDORPREFIX} ||= $u_vprefix || $vprefix;
1902 my $arch = $Config{archname};
1903 my $version = $Config{version};
1906 my $libstyle = 'lib/perl5';
1909 if( $self->{LIBSTYLE} ) {
1910 $libstyle = $self->{LIBSTYLE};
1911 $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
1916 bin => { s => $iprefix,
1919 vendorbin => { s => $vprefix,
1920 r => '$(VENDORPREFIX)',
1922 sitebin => { s => $sprefix,
1923 r => '$(SITEPREFIX)',
1925 script => { s => $iprefix,
1932 man1dir => { s => $iprefix,
1934 d => 'man/man$(MAN1EXT)',
1935 style => $manstyle, },
1936 siteman1dir => { s => $sprefix,
1937 r => '$(SITEPREFIX)',
1938 d => 'man/man$(MAN1EXT)',
1939 style => $manstyle, },
1940 vendorman1dir => { s => $vprefix,
1941 r => '$(VENDORPREFIX)',
1942 d => 'man/man$(MAN1EXT)',
1943 style => $manstyle, },
1945 man3dir => { s => $iprefix,
1947 d => 'man/man$(MAN3EXT)',
1948 style => $manstyle, },
1949 siteman3dir => { s => $sprefix,
1950 r => '$(SITEPREFIX)',
1951 d => 'man/man$(MAN3EXT)',
1952 style => $manstyle, },
1953 vendorman3dir => { s => $vprefix,
1954 r => '$(VENDORPREFIX)',
1955 d => 'man/man$(MAN3EXT)',
1956 style => $manstyle, },
1961 privlib => { s => $iprefix,
1964 style => $libstyle, },
1965 vendorlib => { s => $vprefix,
1966 r => '$(VENDORPREFIX)',
1968 style => $libstyle, },
1969 sitelib => { s => $sprefix,
1970 r => '$(SITEPREFIX)',
1972 style => $libstyle, },
1974 archlib => { s => $iprefix,
1976 d => "$version/$arch",
1977 style => $libstyle },
1978 vendorarch => { s => $vprefix,
1979 r => '$(VENDORPREFIX)',
1980 d => "$version/$arch",
1981 style => $libstyle },
1982 sitearch => { s => $sprefix,
1983 r => '$(SITEPREFIX)',
1984 d => "site_perl/$version/$arch",
1985 style => $libstyle },
1989 # Special case for LIB.
1990 if( $self->{LIB} ) {
1991 foreach my $var (keys %lib_layouts) {
1992 my $Installvar = uc "install$var";
1994 if( $var =~ /arch/ ) {
1995 $self->{$Installvar} ||=
1996 File::Spec->catdir($self->{LIB}, $Config{archname});
1999 $self->{$Installvar} ||= $self->{LIB};
2005 my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
2006 while( my($var, $layout) = each(%layouts) ) {
2007 my($s, $r, $d, $style) = @{$layout}{qw(s r d style)};
2009 print STDERR "Prefixing $var\n" if $Verbose >= 2;
2011 my $installvar = "install$var";
2012 my $Installvar = uc $installvar;
2013 next if $self->{$Installvar};
2016 $d = "$style/$d" if $style;
2017 $self->prefixify($installvar, $s, $r, $d);
2020 $self->{$Installvar} = $Config_Override{$installvar} ||
2021 $Config{$installvar};
2024 print STDERR " $Installvar == $self->{$Installvar}\n"
2028 $self->{PREFIX} ||= $iprefix;
2038 Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the
2039 *PERLRUN* permutations.
2041 PERL is allowed to be miniperl
2042 FULLPERL must be a complete perl
2043 ABSPERL is PERL converted to an absolute path
2045 *PERLRUN contains everything necessary to run perl, find it's
2048 *PERLRUNINST is *PERLRUN + everything necessary to find the
2049 modules being built.
2057 foreach my $component ($self->{PERL_SRC}, $self->path(),
2060 push @defpath, $component if defined $component;
2063 # Build up a set of file names (not command names).
2064 my $thisperl = File::Spec->canonpath($^X);
2065 $thisperl .= $Config{exe_ext} unless $thisperl =~ m/$Config{exe_ext}$/i;
2066 my @perls = ($thisperl);
2067 push @perls, map { "$_$Config{exe_ext}" }
2068 ('perl', 'perl5', "perl$Config{version}");
2070 # miniperl has priority over all but the cannonical perl when in the
2071 # core. Otherwise its a last resort.
2072 my $miniperl = "miniperl$Config{exe_ext}";
2073 if( $self->{PERL_CORE} ) {
2074 splice @perls, 1, 0, $miniperl;
2077 push @perls, $miniperl;
2081 $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
2082 # don't check if perl is executable, maybe they have decided to
2083 # supply switches with perl
2085 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2086 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
2087 unless $self->{FULLPERL};
2089 # Little hack to get around VMS's find_perl putting "MCR" in front
2091 $self->{ABSPERL} = $self->{PERL};
2092 my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2093 if( File::Spec->file_name_is_absolute($self->{ABSPERL}) ) {
2094 $self->{ABSPERL} = '$(PERL)';
2097 $self->{ABSPERL} = File::Spec->rel2abs($self->{ABSPERL});
2098 $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2101 # Are we building the core?
2102 $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2104 # How do we run perl?
2105 foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2106 $self->{$perl.'RUN'} = "\$($perl)";
2108 # Make sure perl can find itself before it's installed.
2109 $self->{$perl.'RUN'} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
2110 if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2112 $self->{$perl.'RUNINST'} =
2113 sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2123 Called by init_main. Initializes PERL_*
2130 $self->{PERM_RW} = 644;
2131 $self->{PERM_RWX} = 755;
2139 Defines the install target.
2144 my($self, %attribs) = @_;
2148 install :: all pure_install doc_install
2150 install_perl :: all pure_perl_install doc_perl_install
2152 install_site :: all pure_site_install doc_site_install
2154 install_vendor :: all pure_vendor_install doc_vendor_install
2156 pure_install :: pure_$(INSTALLDIRS)_install
2158 doc_install :: doc_$(INSTALLDIRS)_install
2159 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2161 pure__install : pure_site_install
2162 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2164 doc__install : doc_site_install
2165 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2167 pure_perl_install ::
2168 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2169 read }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2170 write }.File::Spec->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2171 $(INST_LIB) $(INSTALLPRIVLIB) \
2172 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2173 $(INST_BIN) $(INSTALLBIN) \
2174 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2175 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2176 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2177 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2178 }.File::Spec->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2181 pure_site_install ::
2182 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2183 read }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2184 write }.File::Spec->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2185 $(INST_LIB) $(INSTALLSITELIB) \
2186 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2187 $(INST_BIN) $(INSTALLSITEBIN) \
2188 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2189 $(INST_MAN1DIR) $(INSTALLSITEMAN1DIR) \
2190 $(INST_MAN3DIR) $(INSTALLSITEMAN3DIR)
2191 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2192 }.File::Spec->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2194 pure_vendor_install ::
2195 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2196 $(INST_LIB) $(INSTALLVENDORLIB) \
2197 $(INST_ARCHLIB) $(INSTALLVENDORARCH) \
2198 $(INST_BIN) $(INSTALLVENDORBIN) \
2199 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2200 $(INST_MAN1DIR) $(INSTALLVENDORMAN1DIR) \
2201 $(INST_MAN3DIR) $(INSTALLVENDORMAN3DIR)
2204 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2205 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2206 "Module" "$(NAME)" \
2207 "installed into" "$(INSTALLPRIVLIB)" \
2208 LINKTYPE "$(LINKTYPE)" \
2209 VERSION "$(VERSION)" \
2210 EXE_FILES "$(EXE_FILES)" \
2211 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2214 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2215 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2216 "Module" "$(NAME)" \
2217 "installed into" "$(INSTALLSITELIB)" \
2218 LINKTYPE "$(LINKTYPE)" \
2219 VERSION "$(VERSION)" \
2220 EXE_FILES "$(EXE_FILES)" \
2221 >> }.File::Spec->catfile('$(INSTALLSITEARCH)','perllocal.pod').q{
2223 doc_vendor_install ::
2228 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2230 uninstall_from_perldirs ::
2232 q{$(UNINSTALL) }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2234 uninstall_from_sitedirs ::
2236 q{$(UNINSTALL) }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2242 =item installbin (o)
2244 Defines targets to make and to install EXE_FILES.
2250 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2251 return "" unless @{$self->{EXE_FILES}};
2252 my(@m, $from, $to, %fromto, @to);
2253 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2254 for $from (@{$self->{EXE_FILES}}) {
2255 my($path)= File::Spec->catfile('$(INST_SCRIPT)', basename($from));
2256 local($_) = $path; # for backwards compatibility
2257 $to = $self->libscan($path);
2258 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2261 @to = values %fromto;
2263 EXE_FILES = @{$self->{EXE_FILES}}
2265 } . (($Is_Win32 || $Is_NetWare)
2266 ? q{FIXIN = pl2bat.bat
2267 } : q{FIXIN = $(PERLRUN) "-MExtUtils::MY" \
2268 -e "MY->fixin(shift)"
2271 $self->{NOECHO}\$(NOOP)
2277 while (($from,$to) = each %fromto) {
2278 last unless defined $from;
2279 my $todir = dirname($to);
2281 $to: $from $self->{MAKEFILE} " . File::Spec->catdir($todir,'.exists') . "
2282 $self->{NOECHO}$self->{RM_F} $to
2283 $self->{CP} $from $to
2285 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2293 Takes a path to a file that is found by init_dirscan and returns false
2294 if we don't want to include this file in the library. Mainly used to
2295 exclude RCS, CVS, and SCCS directories from installation.
2302 my($self,$path) = @_;
2303 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2309 Defines the linkext target which in turn defines the LINKTYPE.
2314 my($self, %attribs) = @_;
2315 # LINKTYPE => static or dynamic or ''
2316 my($linktype) = defined $attribs{LINKTYPE} ?
2317 $attribs{LINKTYPE} : '$(LINKTYPE)';
2319 linkext :: $linktype
2320 $self->{NOECHO}\$(NOOP)
2326 Takes as arguments a directory name and a regular expression. Returns
2327 all entries in the directory that match the regular expression.
2333 my($dir, $regex) = @_;
2335 my $dh = new DirHandle;
2336 $dh->open($dir || ".") or return ();
2339 @ls = grep(/$regex/, @ls) if $regex;
2345 Simple subroutine to insert the macros defined by the macro attribute
2351 my($self,%attribs) = @_;
2353 while (($key,$val) = each %attribs){
2354 last unless defined $key;
2355 push @m, "$key = $val\n";
2362 Called by staticmake. Defines how to write the Makefile to produce a
2365 By default the Makefile produced includes all the static extensions in
2366 the perl library. (Purified versions of library files, e.g.,
2367 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2372 my($self, %attribs) = @_;
2373 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2374 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2377 # --- MakeMaker makeaperl section ---
2378 MAP_TARGET = $target
2379 FULLPERL = $self->{FULLPERL}
2381 return join '', @m if $self->{PARENT};
2383 my($dir) = join ":", @{$self->{DIR}};
2385 unless ($self->{MAKEAPERL}) {
2387 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2388 $(MAKE) -f $(MAKE_APERL_FILE) $@
2390 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2391 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2392 }.$self->{NOECHO}.q{$(PERLRUNINST) \
2393 Makefile.PL DIR=}, $dir, q{ \
2394 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2395 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2401 push @m, " \\\n\t\t$_";
2403 # push @m, map( " \\\n\t\t$_", @ARGV );
2411 my($cccmd, $linkcmd, $lperl);
2414 $cccmd = $self->const_cccmd($libperl);
2415 $cccmd =~ s/^CCCMD\s*=\s*//;
2416 $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2417 $cccmd .= " $Config{cccdlflags}"
2418 if ($Config{useshrplib} eq 'true');
2419 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2421 # The front matter of the linkcommand...
2422 $linkcmd = join ' ', "\$(CC)",
2423 grep($_, @Config{qw(ldflags ccdlflags)});
2424 $linkcmd =~ s/\s+/ /g;
2425 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2427 # Which *.a files could we make use of...
2430 File::Find::find(sub {
2431 return unless m/\Q$self->{LIB_EXT}\E$/;
2432 return if m/^libperl/;
2433 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2434 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2436 if( exists $self->{INCLUDE_EXT} ){
2441 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2445 # Throw away anything not explicitly marked for inclusion.
2446 # DynaLoader is implied.
2447 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2453 return unless $found;
2455 elsif( exists $self->{EXCLUDE_EXT} ){
2459 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2463 # Throw away anything explicitly marked for exclusion
2464 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2465 return if( $xx eq $excl );
2469 # don't include the installed version of this extension. I
2470 # leave this line here, although it is not necessary anymore:
2471 # I patched minimod.PL instead, so that Miniperl.pm won't
2472 # enclude duplicates
2474 # Once the patch to minimod.PL is in the distribution, I can
2476 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2478 $static{cwd() . "/" . $_}++;
2479 }, grep( -d $_, @{$searchdirs || []}) );
2481 # We trust that what has been handed in as argument, will be buildable
2482 $static = [] unless $static;
2483 @static{@{$static}} = (1) x @{$static};
2485 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2486 for (sort keys %static) {
2487 next unless /\Q$self->{LIB_EXT}\E\z/;
2488 $_ = dirname($_) . "/extralibs.ld";
2492 grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2497 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2498 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2499 # extralibs.all are computed correctly
2501 MAP_LINKCMD = $linkcmd
2502 MAP_PERLINC = @{$perlinc || []}
2504 join(" \\\n\t", reverse sort keys %static), "
2506 MAP_PRELIBS = $Config{perllibs} $Config{cryptlib}
2509 if (defined $libperl) {
2510 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2512 unless ($libperl && -f $lperl) { # Ilya's code...
2513 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2514 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2515 $libperl ||= "libperl$self->{LIB_EXT}";
2516 $libperl = "$dir/$libperl";
2517 $lperl ||= "libperl$self->{LIB_EXT}";
2518 $lperl = "$dir/$lperl";
2520 if (! -f $libperl and ! -f $lperl) {
2521 # We did not find a static libperl. Maybe there is a shared one?
2522 if ($^O eq 'solaris' or $^O eq 'sunos') {
2523 $lperl = $libperl = "$dir/$Config{libperl}";
2524 # SUNOS ld does not take the full path to a shared library
2525 $libperl = '' if $^O eq 'sunos';
2529 print STDOUT "Warning: $libperl not found
2530 If you're going to build a static perl binary, make sure perl is installed
2531 otherwise ignore this warning\n"
2532 unless (-f $lperl || defined($self->{PERL_SRC}));
2535 # SUNOS ld does not take the full path to a shared library
2536 my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2539 MAP_LIBPERL = $libperl
2540 LLIBPERL = $llibperl
2544 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2545 $self->{NOECHO}$self->{RM_F} \$\@
2546 $self->{NOECHO}\$(TOUCH) \$\@
2550 foreach $catfile (@$extra){
2551 push @m, "\tcat $catfile >> \$\@\n";
2555 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2556 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2557 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2558 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2559 $self->{NOECHO}echo 'To remove the intermediate files say'
2560 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2562 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2564 push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2567 $tmp/perlmain.c: $makefilename}, q{
2568 }.$self->{NOECHO}.q{echo Writing $@
2569 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2570 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2573 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2574 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2579 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2580 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2581 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2582 "Perl binary" "$(MAP_TARGET)" \
2583 MAP_STATIC "$(MAP_STATIC)" \
2584 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2585 MAP_LIBPERL "$(MAP_LIBPERL)" \
2586 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2591 inst_perl: pure_inst_perl doc_inst_perl
2593 pure_inst_perl: $(MAP_TARGET)
2594 }.$self->{CP}.q{ $(MAP_TARGET) }.File::Spec->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2599 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2607 Defines how to rewrite the Makefile.
2614 # We do not know what target was originally specified so we
2615 # must force a manual rerun to be sure. But as it should only
2616 # happen very rarely it is not a significant problem.
2618 $(OBJECT) : $(FIRST_MAKEFILE)
2619 ' if $self->{OBJECT};
2622 # We take a very conservative approach here, but it\'s worth it.
2623 # We move Makefile to Makefile.old here to avoid gnu make looping.
2624 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2625 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2626 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2627 -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2628 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2629 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2630 $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2631 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2632 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2640 =item manifypods (o)
2642 Defines targets and routines to translate the pods into manpages and
2643 put them into the INST_* directories.
2648 my($self, %attribs) = @_;
2649 return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2650 %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2653 if (defined $self->{PERL_SRC}) {
2654 $pod2man_exe = File::Spec->catfile($self->{PERL_SRC},'pod','pod2man');
2656 $pod2man_exe = File::Spec->catfile($Config{scriptdirexp},'pod2man');
2658 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2659 # Maybe a build by uninstalled Perl?
2660 $pod2man_exe = File::Spec->catfile($self->{PERL_INC}, "pod", "pod2man");
2662 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2663 # No pod2man but some MAN3PODS to be installed
2666 Warning: I could not locate your pod2man program. Please make sure,
2667 your pod2man program is in your PATH before you execute 'make'
2670 $pod2man_exe = "-S pod2man";
2674 qq[POD2MAN_EXE = $pod2man_exe\n],
2675 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2676 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2677 $self->{MAKEFILE}, q[";' \\
2678 -e 'print "Manifying $$m{$$_}\n";' \\
2679 -e 'system(q[$(PERLRUN) $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2680 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2682 push @m, "\nmanifypods : pure_all ";
2683 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2686 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2687 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2688 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2695 Returns true, if the argument is likely to be a command.
2700 my($self,$file) = @_;
2701 return $file if -x $file && ! -d $file;
2705 =item maybe_command_in_dirs
2707 method under development. Not yet used. Ask Ilya :-)
2711 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2712 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2713 my($self, $names, $dirs, $trace, $ver) = @_;
2715 foreach $dir (@$dirs){
2716 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2717 foreach $name (@$names){
2719 if (File::Spec->file_name_is_absolute($name)) { # /foo/bar
2721 } elsif (File::Spec->canonpath($name) eq File::Spec->canonpath(basename($name))) { # bar
2722 $abs = File::Spec->catfile($dir, $name);
2724 $abs = File::Spec->catfile($Curdir, $name);
2726 print "Checking $abs for $name\n" if ($trace >= 2);
2727 next unless $tryabs = $self->maybe_command($abs);
2728 print "Substituting $tryabs instead of $abs\n"
2729 if ($trace >= 2 and $tryabs ne $abs);
2732 print "Executing $abs\n" if ($trace >= 2);
2733 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2734 print "Using PERL=$abs\n" if $trace;
2737 } else { # Do not look for perl
2744 =item needs_linking (o)
2746 Does this module need linking? Looks into subdirectory objects (see
2747 also has_link_code())
2754 $caller = (caller(0))[3];
2755 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2756 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2757 if ($self->has_link_code or $self->{MAKEAPERL}){
2758 $self->{NEEDS_LINKING} = 1;
2761 foreach $child (keys %{$self->{CHILDREN}}) {
2762 if ($self->{CHILDREN}->{$child}->needs_linking) {
2763 $self->{NEEDS_LINKING} = 1;
2767 return $self->{NEEDS_LINKING} = 0;
2772 misnamed method (will have to be changed). The MM_Unix method just
2773 returns the argument without further processing.
2775 On VMS used to insure that colons marking targets are preceded by
2776 space - most Unix Makes don't need this, but it's necessary under VMS
2777 to distinguish the target delimiter from a colon appearing as part of
2783 my($self,$text) = @_;
2787 =item parse_abstract
2789 parse a file and return what you think is the ABSTRACT
2793 sub parse_abstract {
2794 my($self,$parsefile) = @_;
2798 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2800 my $package = $self->{DISTNAME};
2801 $package =~ s/-/::/g;
2803 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2806 next unless /^($package\s-\s)(.*)/;
2816 parse a file and return what you think is $VERSION in this file set to.
2817 It will return the string "undef" if it can't figure out what $VERSION
2818 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
2819 are okay, but my $VERSION is not.
2824 my($self,$parsefile) = @_;
2828 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2831 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2832 next if $inpod || /^\s*#/;
2834 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2835 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2837 package ExtUtils::MakeMaker::_version;
2846 $result = eval($eval);
2847 warn "Could not eval '$eval' in $parsefile: $@" if $@;
2848 $result = "undef" unless defined $result;
2858 Defines the string that is passed to recursive make calls in
2868 my($sep) = $Is_VMS ? ',' : '';
2871 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
2872 push @pasthru, "$key=\"\$($key)\"";
2875 foreach $key (qw(DEFINE INC)) {
2876 push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2879 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2885 Takes one argument, a file name, and returns the file name, if the
2886 argument is likely to be a perl script. On MM_Unix this is true for
2887 any ordinary, readable file.
2892 my($self,$file) = @_;
2893 return $file if -r $file && -f _;
2897 =item perldepend (o)
2899 Defines the dependency from all *.h files that come with the perl
2908 # Check for unpropogated config.sh changes. Should never happen.
2909 # We do NOT just update config.h because that is not sufficient.
2910 # An out of date config.h is not fatal but complains loudly!
2911 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2912 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2914 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2915 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2916 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2917 } if $self->{PERL_SRC};
2919 return join "", @m unless $self->needs_linking;
2923 $(PERL_INC)/EXTERN.h \
2924 $(PERL_INC)/INTERN.h \
2925 $(PERL_INC)/XSUB.h \
2927 $(PERL_INC)/cc_runtime.h \
2928 $(PERL_INC)/config.h \
2931 $(PERL_INC)/dosish.h \
2932 $(PERL_INC)/embed.h \
2933 $(PERL_INC)/embedvar.h \
2934 $(PERL_INC)/fakethr.h \
2935 $(PERL_INC)/form.h \
2937 $(PERL_INC)/handy.h \
2939 $(PERL_INC)/intrpvar.h \
2940 $(PERL_INC)/iperlsys.h \
2941 $(PERL_INC)/keywords.h \
2943 $(PERL_INC)/nostdio.h \
2945 $(PERL_INC)/opcode.h \
2946 $(PERL_INC)/opnames.h \
2947 $(PERL_INC)/patchlevel.h \
2948 $(PERL_INC)/perl.h \
2949 $(PERL_INC)/perlapi.h \
2950 $(PERL_INC)/perlio.h \
2951 $(PERL_INC)/perlsdio.h \
2952 $(PERL_INC)/perlsfio.h \
2953 $(PERL_INC)/perlvars.h \
2954 $(PERL_INC)/perly.h \
2956 $(PERL_INC)/pp_proto.h \
2957 $(PERL_INC)/proto.h \
2958 $(PERL_INC)/regcomp.h \
2959 $(PERL_INC)/regexp.h \
2960 $(PERL_INC)/regnodes.h \
2961 $(PERL_INC)/scope.h \
2963 $(PERL_INC)/thrdvar.h \
2964 $(PERL_INC)/thread.h \
2965 $(PERL_INC)/unixish.h \
2966 $(PERL_INC)/utf8.h \
2967 $(PERL_INC)/util.h \
2968 $(PERL_INC)/warnings.h
2970 $(OBJECT) : $(PERL_HDRS)
2971 } if $self->{OBJECT};
2973 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2981 Returns the attribute C<PERM_RW> or the string C<644>.
2982 Used as the string that is passed
2983 to the C<chmod> command to set the permissions for read/writeable files.
2984 MakeMaker chooses C<644> because it has turned out in the past that
2985 relying on the umask provokes hard-to-track bug reports.
2986 When the return value is used by the perl function C<chmod>, it is
2987 interpreted as an octal value.
2992 shift->{PERM_RW} || "644";
2997 Returns the attribute C<PERM_RWX> or the string C<755>,
2998 i.e. the string that is passed
2999 to the C<chmod> command to set the permissions for executable files.
3005 shift->{PERM_RWX} || "755";
3010 Defines target that copies all files in the hash PM to their
3011 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3015 sub _pm_to_blib_flush {
3016 my ($self, $autodir, $rr, $ra, $rl) = @_;
3018 q{ }.$self->{NOECHO}.q[$(PERLRUNINST) "-MExtUtils::Install" \
3019 -e "pm_to_blib({qw{].qq[@$ra].q[}},'].$autodir.q{','$(PM_FILTER)')"
3027 my($autodir) = File::Spec->catdir('$(INST_LIB)','auto');
3029 pm_to_blib: $(TO_INST_PM)
3031 my %pm_to_blib = %{$self->{PM}};
3034 while (my ($pm, $blib) = each %pm_to_blib) {
3035 my $la = length $pm;
3036 my $lb = length $blib;
3037 if ($l + $la + $lb + @a / 2 > 200) { # limit line length
3038 _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3040 push @a, $pm, $blib;
3043 _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3044 return $r.q{ }.$self->{NOECHO}.q{$(TOUCH) $@};
3047 =item post_constants (o)
3049 Returns an empty string per default. Dedicated to overrides from
3050 within Makefile.PL after all constants have been defined.
3059 =item post_initialize (o)
3061 Returns an empty string per default. Used in Makefile.PLs to add some
3062 chunk of text to the Makefile after the object is initialized.
3066 sub post_initialize {
3073 Returns an empty string. Can be used in Makefile.PLs to write some
3074 text to the Makefile at the end.
3085 Defines target that creates a PPD (Perl Package Description) file
3086 for a binary distribution.
3093 if ($self->{ABSTRACT_FROM}){
3094 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3095 Carp::carp "WARNING: Setting ABSTRACT via file ".
3096 "'$self->{ABSTRACT_FROM}' failed\n";
3099 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
3101 my $abstract = $self->{ABSTRACT} || '';
3102 $abstract =~ s/\n/\\n/sg;
3103 $abstract =~ s/</</g;
3104 $abstract =~ s/>/>/g;
3106 my $author = $self->{AUTHOR} || '';
3107 $author =~ s/</</g;
3108 $author =~ s/>/>/g;
3109 $author =~ s/@/\\@/g;
3111 my $make_ppd = sprintf <<'PPD_OUT', $pack_ver, $abstract, $author;
3112 # Creates a PPD (Perl Package Description) for a binary distribution.
3114 @$(PERL) -e "print qq{<SOFTPKG NAME=\"$(DISTNAME)\" VERSION=\"%s\">\n\t<TITLE>$(DISTNAME)</TITLE>\n\t<ABSTRACT>%s</ABSTRACT>\n\t<AUTHOR>%s</AUTHOR>\n}" > $(DISTNAME).ppd
3118 $make_ppd .= ' @$(PERL) -e "print qq{\t<IMPLEMENTATION>\n';
3119 foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3120 my $pre_req = $prereq;
3121 $pre_req =~ s/::/-/g;
3122 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
3124 $make_ppd .= sprintf q{\t\t<DEPENDENCY NAME=\"%s\" VERSION=\"%s\" />\n}, $pre_req, $dep_ver;
3126 $make_ppd .= qq[}" >> \$(DISTNAME).ppd\n];
3129 $make_ppd .= sprintf <<'PPD_OUT', $Config{archname};
3130 @$(PERL) -e "print qq{\t\t<OS NAME=\"$(OSNAME)\" />\n\t\t<ARCHITECTURE NAME=\"%s\" />\n
3136 if ($self->{PPM_INSTALL_SCRIPT}) {
3137 if ($self->{PPM_INSTALL_EXEC}) {
3138 $make_ppd .= sprintf q{\t\t<INSTALL EXEC=\"%s\">%s</INSTALL>\n},
3139 $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3142 $make_ppd .= sprintf q{\t\t<INSTALL>%s</INSTALL>\n},
3143 $self->{PPM_INSTALL_SCRIPT};
3147 my ($bin_location) = $self->{BINARY_LOCATION} || '';
3148 $bin_location =~ s/\\/\\\\/g;
3150 $make_ppd .= sprintf q{\t\t<CODEBASE HREF=\"%s\" />\n}, $bin_location;
3151 $make_ppd .= q{\t</IMPLEMENTATION>\n};
3152 $make_ppd .= q{</SOFTPKG>\n};
3154 $make_ppd .= '}" >> $(DISTNAME).ppd';
3161 $MM->prefixify($var, $prefix, $new_prefix, $default);
3163 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3164 replace it's $prefix with a $new_prefix. Should the $prefix fail to
3165 match it sill simply set it to the $new_prefix + $default.
3167 This is for heuristics which attempt to create directory structures
3168 that mirror those of the installed perl.
3172 $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3174 this will attempt to remove '/usr' from the front of the
3175 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3176 if necessary) and replace it with '/home/foo'. If this fails it will
3177 simply use '/home/foo/man/man1'.
3182 my($self,$var,$sprefix,$rprefix,$default) = @_;
3184 my $path = $self->{uc $var} ||
3185 $Config_Override{lc $var} || $Config{lc $var};
3187 print STDERR " prefixify $var=$path\n" if $Verbose >= 2;
3188 print STDERR " from $sprefix to $rprefix\n"
3191 $path = VMS::Filespec::unixpath($path) if $Is_VMS;
3193 unless( $path =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s ) {
3195 print STDERR " cannot prefix, using default.\n" if $Verbose >= 2;
3196 print STDERR " no default!\n" if !$default && $Verbose >= 2;
3198 $path = File::Spec->catdir($rprefix, $default) if $default;
3201 print " now $path\n" if $Verbose >= 2;
3202 return $self->{uc $var} = $path;
3208 Defines targets to run *.PL files.
3214 return "" unless $self->{PL_FILES};
3216 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3217 my $list = ref($self->{PL_FILES}->{$plfile})
3218 ? $self->{PL_FILES}->{$plfile}
3219 : [$self->{PL_FILES}->{$plfile}];
3221 foreach $target (@$list) {
3224 $self->{NOECHO}\$(NOOP)
3227 \$(PERLRUNINST) $plfile $target
3236 Backslashes parentheses C<()> in command line arguments.
3237 Doesn't handle recursive Makefile C<$(...)> constructs,
3238 but handles simple ones.
3244 s/\$\((.+?)\)/\$\\\\($1\\\\)/g; # protect $(...)
3245 s/(?<!\\)([()])/\\$1/g; # quote unprotected
3246 s/\$\\\\\((.+?)\\\\\)/\$($1)/g; # unprotect $(...)
3252 Defines the realclean target.
3257 my($self, %attribs) = @_;
3261 # Delete temporary files (via clean) and also delete installed files
3262 realclean purge :: clean
3264 # realclean subdirectories first (already cleaned)
3266 if( $Is_Win32 && Win32::IsWin95() ) {
3267 $sub = <<'REALCLEAN';
3269 -$(PERLRUN) -e "exit unless -f shift; system q{$(MAKE) realclean}" %s
3274 $sub = <<'REALCLEAN';
3275 -cd %s && $(TEST_F) %s && $(MAKE) %s realclean
3279 foreach(@{$self->{DIR}}){
3280 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3281 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3283 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3284 push(@m, " $self->{RM_RF} \$(DISTVNAME)\n");
3285 if( $self->has_link_code ){
3286 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3287 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
3289 # Issue a several little RM_F commands rather than risk creating a
3290 # very long command line (useful for extensions such as Encode
3291 # that have many files).
3292 if (keys %{$self->{PM}}) {
3294 foreach (values %{$self->{PM}}) {
3295 if (length($line) + length($_) > 80) {
3296 push @m, "\t$self->{RM_F} $line\n";
3303 push @m, "\t$self->{RM_F} $line\n" if $line;
3305 my(@otherfiles) = ($self->{MAKEFILE},
3306 "$self->{MAKEFILE}.old"); # Makefiles last
3307 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3308 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
3309 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
3313 =item replace_manpage_separator
3315 my $man_name = $MM->replace_manpage_separator($file_path);
3317 Takes the name of a package, which may be a nested package, in the
3318 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3319 safe for a man page file name. Returns the replacement.
3323 sub replace_manpage_separator {
3324 my($self,$man) = @_;
3332 Defines the static target.
3337 # --- Static Loading Sections ---
3341 ## $(INST_PM) has been moved to the all: target.
3342 ## It remains here for awhile to allow for old usage: "make static"
3343 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3344 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3345 '.$self->{NOECHO}.'$(NOOP)
3349 =item static_lib (o)
3351 Defines how to produce the *.a (or equivalent) files.
3357 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3358 # return '' unless $self->needs_linking(); #might be because of a subdir
3360 return '' unless $self->has_link_code;
3364 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3367 # If this extension has its own library (eg SDBM_File)
3368 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3369 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3372 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3373 # Prefer the absolute pathed ar if available so that PATH
3374 # doesn't confuse us. Perl itself is built with the full_ar.
3380 "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3382 q{ $(CHMOD) $(PERM_RWX) $@
3383 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3385 # Old mechanism - still available:
3387 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3388 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
3391 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3395 =item staticmake (o)
3402 my($self, %attribs) = @_;
3405 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3407 # And as it's not yet built, we add the current extension
3408 # but only if it has some C code (or XS code, which implies C code)
3409 if (@{$self->{C}}) {
3410 @static = File::Spec->catfile($self->{INST_ARCHLIB},
3413 "$self->{BASEEXT}$self->{LIB_EXT}"
3417 # Either we determine now, which libraries we will produce in the
3418 # subdirectories or we do it at runtime of the make.
3420 # We could ask all subdir objects, but I cannot imagine, why it
3421 # would be necessary.
3423 # Instead we determine all libraries for the new perl at
3425 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3427 $self->makeaperl(MAKE => $self->{MAKEFILE},
3428 DIRS => \@searchdirs,
3431 TARGET => $self->{MAP_TARGET},
3433 LIBPERL => $self->{LIBPERL_A}
3439 Helper subroutine for subdirs
3444 my($self, $subdir) = @_;
3446 if ($Is_Win32 && Win32::IsWin95()) {
3447 if ($Config{'make'} =~ /dmake/i) {
3453 \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3457 } elsif ($Config{'make'} =~ /nmake/i) {
3462 \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3470 $self->{NOECHO}cd $subdir && \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3477 Defines targets to process subdirectories.
3482 # --- Sub-directory Sections ---
3485 # This method provides a mechanism to automatically deal with
3486 # subdirectories containing further Makefile.PL scripts.
3487 # It calls the subdir_x() method for each subdirectory.
3488 foreach $dir (@{$self->{DIR}}){
3489 push(@m, $self->subdir_x($dir));
3490 #### print "Including $dir subdirectory\n";
3494 # The default clean, realclean and test targets in this Makefile
3495 # have automatically been given entries for each subdir.
3499 push(@m, "\n# none")
3506 Defines the test targets.
3511 # --- Test and Installation Sections ---
3513 my($self, %attribs) = @_;
3514 my $tests = $attribs{TESTS} || '';
3515 if (!$tests && -d 't') {
3516 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3518 # note: 'test.pl' name is also hardcoded in init_dirscan()
3522 TEST_TYPE=test_\$(LINKTYPE)
3527 testdb :: testdb_\$(LINKTYPE)
3529 test :: \$(TEST_TYPE)
3532 if ($Is_Win32 && Win32::IsWin95()) {
3533 push(@m, map(qq{\t$self->{NOECHO}\$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q{\$(MAKE) test \$(PASTHRU)}" $self->{MAKEFILE}\n}, @{$self->{DIR}}));
3536 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3539 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3540 unless $tests or -f "test.pl" or @{$self->{DIR}};
3543 push(@m, "test_dynamic :: pure_all\n");
3544 push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3546 push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3550 push(@m, "testdb_dynamic :: pure_all\n");
3551 push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3555 # Occasionally we may face this degenerate target:
3556 push @m, "test_ : test_dynamic\n\n";
3558 if ($self->needs_linking()) {
3559 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3560 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3561 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3563 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3564 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3567 push @m, "test_static :: test_dynamic\n";
3568 push @m, "testdb_static :: testdb_dynamic\n";
3573 =item test_via_harness (override)
3575 For some reason which I forget, Unix machines like to have
3576 PERL_DL_NONLAZY set for tests.
3580 sub test_via_harness {
3581 my($self, $perl, $tests) = @_;
3582 return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3585 =item test_via_script (override)
3587 Again, the PERL_DL_NONLAZY thing.
3591 sub test_via_script {
3592 my($self, $perl, $script) = @_;
3593 return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3596 =item tool_autosplit (o)
3598 Defines a simple perl call that runs autosplit. May be deprecated by
3603 sub tool_autosplit {
3604 my($self, %attribs) = @_;
3606 $asl = "\$\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3608 return sprintf <<'MAKE_FRAG', $asl;
3609 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3610 AUTOSPLITFILE = $(PERLRUN) -e 'use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3616 =item tools_other (o)
3618 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3619 the Makefile. Also defines the perl programs MKPATH,
3620 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3627 my $bin_sh = $Config{sh} || '/bin/sh';
3632 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3633 push @m, "$_ = $self->{$_}\n";
3637 # The following is a portable way to say mkdir -p
3638 # To see which directories are created, change the if 0 to if 1
3639 MKPATH = $(PERLRUN) "-MExtUtils::Command" -e mkpath
3641 # This helps us to minimize the effect of the .exists files A yet
3642 # better solution would be to have a stable file in the perl
3643 # distribution with a timestamp of zero. But this solution doesn't
3644 # need any changes to the core distribution and works with older perls
3645 EQUALIZE_TIMESTAMP = $(PERLRUN) "-MExtUtils::Command" -e eqtime
3649 return join "", @m if $self->{PARENT};
3652 # Here we warn users that an old packlist file was found somewhere,
3653 # and that they should call some uninstall routine
3654 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3655 -e 'print "WARNING: I have found an old package in\n";' \\
3656 -e 'print "\t$$ARGV[0].\n";' \\
3657 -e 'print "Please make sure the two installations are not conflicting\n";'
3662 MOD_INSTALL = $(PERL) "-I$(INST_LIB)" "-I$(PERL_LIB)" "-MExtUtils::Install" \
3663 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3665 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3666 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3667 -e 'print "=over 4";' \
3668 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3671 UNINSTALL = $(PERLRUN) "-MExtUtils::Install" \
3672 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3673 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3674 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3680 =item tool_xsubpp (o)
3682 Determines typemaps, xsubpp version, prototype behaviour.
3688 return "" unless $self->needs_linking;
3689 my($xsdir) = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3690 my(@tmdeps) = File::Spec->catdir('$(XSUBPPDIR)','typemap');
3691 if( $self->{TYPEMAPS} ){
3693 foreach $typemap (@{$self->{TYPEMAPS}}){
3694 if( ! -f $typemap ){
3695 warn "Typemap $typemap not found.\n";
3698 push(@tmdeps, $typemap);
3702 push(@tmdeps, "typemap") if -f "typemap";
3703 my(@tmargs) = map("-typemap $_", @tmdeps);
3704 if( exists $self->{XSOPT} ){
3705 unshift( @tmargs, $self->{XSOPT} );
3709 my $xsubpp_version = $self->xsubpp_version(File::Spec->catfile($xsdir,"xsubpp"));
3711 # What are the correct thresholds for version 1 && 2 Paul?
3712 if ( $xsubpp_version > 1.923 ){
3713 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3715 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3716 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3717 Your version of xsubpp is $xsubpp_version and cannot handle this.
3718 Please upgrade to a more recent version of xsubpp.
3721 $self->{XSPROTOARG} = "";
3725 my $xsubpp = "xsubpp";
3729 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3730 XSPROTOARG = $self->{XSPROTOARG}
3731 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3732 XSUBPPARGS = @tmargs
3739 my($self,$xsubpp) = @_;
3740 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3744 # try to figure out the version number of the xsubpp on the system
3746 # first try the -v flag, introduced in 1.921 & 2.000a2
3748 return "" unless $self->needs_linking;
3750 my $command = qq{$self->{PERL} "-I$self->{PERL_LIB}" $xsubpp -v 2>&1};
3751 print "Running $command\n" if $Verbose >= 2;
3752 $version = `$command` ;
3753 warn "Running '$command' exits with status " . ($?>>8) if $?;
3756 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3758 # nope, then try something else
3760 my $counter = '000';
3761 my ($file) = 'temp' ;
3762 $counter++ while -e "$file$counter"; # don't overwrite anything
3765 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3767 MODULE = fred PACKAGE = fred
3776 $command = "$self->{PERL} $xsubpp $file 2>&1";
3777 print "Running $command\n" if $Verbose >= 2;
3778 my $text = `$command` ;
3779 warn "Running '$command' exits with status " . ($?>>8) if $?;
3782 # gets 1.2 -> 1.92 and 2.000a1
3783 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3785 # it is either 1.0 or 1.1
3786 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3788 # none of the above, so 1.0
3789 return $Xsubpp_Version = "1.0" ;
3792 =item top_targets (o)
3794 Defines the targets all, subdirs, config, and O_FILES
3799 # --- Target Sections ---
3805 all :: pure_all manifypods
3806 '.$self->{NOECHO}.'$(NOOP)
3808 unless $self->{SKIPHASH}{'all'};
3811 pure_all :: config pm_to_blib subdirs linkext
3812 '.$self->{NOECHO}.'$(NOOP)
3814 subdirs :: $(MYEXTLIB)
3815 '.$self->{NOECHO}.'$(NOOP)
3817 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3818 '.$self->{NOECHO}.'$(NOOP)
3820 config :: $(INST_ARCHAUTODIR)/.exists
3821 '.$self->{NOECHO}.'$(NOOP)
3823 config :: $(INST_AUTODIR)/.exists
3824 '.$self->{NOECHO}.'$(NOOP)
3827 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3829 if (%{$self->{MAN1PODS}}) {
3831 config :: \$(INST_MAN1DIR)/.exists
3832 $self->{NOECHO}\$(NOOP)
3835 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3837 if (%{$self->{MAN3PODS}}) {
3839 config :: \$(INST_MAN3DIR)/.exists
3840 $self->{NOECHO}\$(NOOP)
3843 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3847 $(O_FILES): $(H_FILES)
3848 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3852 perldoc ExtUtils::MakeMaker
3860 Obsolete, deprecated method. Not used since Version 5.21.
3865 # --- perllocal.pod section ---
3866 my($self,$what,$name,@attribs)=@_;
3867 my $time = localtime;
3868 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3869 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3870 print "\n\n=back\n\n";
3875 Defines the suffix rules to compile XS files to C.
3881 return '' unless $self->needs_linking();
3884 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3890 Defines the suffix rules to compile XS files to C++.
3896 return '' unless $self->needs_linking();
3899 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3905 Defines suffix rules to go from XS to object files directly. This is
3906 only intended for broken make implementations.
3910 sub xs_o { # many makes are too dumb to use xs_c then c_o
3912 return '' unless $self->needs_linking();
3915 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3916 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
3922 This is internal method that returns path to libperl.a equivalent
3923 to be linked to dynamic extensions. UNIX does not have one but other
3933 =item perl_archive_after
3935 This is an internal method that returns path to a library which
3936 should be put on the linker command line I<after> the external libraries
3937 to be linked to dynamic extensions. This may be needed if the linker
3938 is one-pass, and Perl includes some overrides for C RTL functions,
3943 sub perl_archive_after
3950 This is internal method that returns name of a file that is
3951 passed to linker to define symbols to be exported.
3952 UNIX does not have one but OS2 and Win32 do.
3968 L<ExtUtils::MakeMaker>