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
16 $Verbose %pm %static $Xsubpp_Version);
18 use ExtUtils::MakeMaker qw($Verbose neatvalue);
22 require ExtUtils::MM_Any;
23 @ISA = qw(ExtUtils::MM_Any);
25 $Is_OS2 = $^O eq 'os2';
26 $Is_Mac = $^O eq 'MacOS';
27 $Is_Win32 = $^O eq 'MSWin32';
28 $Is_Dos = $^O eq 'dos';
29 $Is_VOS = $^O eq 'vos';
31 if ($Is_VMS = $^O eq 'VMS') {
32 require VMS::Filespec;
33 import VMS::Filespec qw( &vmsify );
38 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
42 C<require ExtUtils::MM_Unix;>
46 The methods provided by this package are designed to be used in
47 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
48 Makefile, it creates one or more objects that inherit their methods
49 from a package C<MM>. MM itself doesn't provide any methods, but it
50 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
51 specific packages take the responsibility for all the methods provided
52 by MM_Unix. We are trying to reduce the number of the necessary
53 overrides by defining rather primitive operations within
56 If you are going to write a platform specific MM package, please try
57 to limit the necessary overrides to primitive methods, and if it is not
58 possible to do so, let's work out how to achieve that gain.
60 If you are overriding any of these methods in your Makefile.PL (in the
61 MY class), please report that to the makemaker mailing list. We are
62 trying to minimize the necessary method overrides and switch to data
63 driven Makefile.PLs wherever possible. In the long run less methods
64 will be overridable via the MY class.
68 The following description of methods is still under
69 development. Please refer to the code for not suitably documented
70 sections and complain loudly to the makemaker mailing list.
72 Not all of the methods below are overridable in a
73 Makefile.PL. Overridable methods are marked as (o). All methods are
74 overridable by a platform specific MM_*.pm file (See
75 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
79 # So we don't have to keep calling the methods over and over again,
80 # we have these globals to cache the values. They have to be global
81 # else the SelfLoaded methods can't see them.
82 use vars qw($Curdir $Rootdir $Updir);
83 $Curdir = File::Spec->curdir;
84 $Rootdir = File::Spec->rootdir;
85 $Updir = File::Spec->updir;
126 sub maybe_command_in_dirs;
133 sub perl_archive_after;
145 sub replace_manpage_separator;
152 sub test_via_harness;
166 # SelfLoader not smart enough to avoid autoloading DESTROY
173 =head2 SelfLoaded methods
179 Defines the suffix rules to compile different flavors of C files to
185 # --- Translation Sections ---
188 return '' unless $self->needs_linking();
190 if (my $cpp = $Config{cpprun}) {
191 my $cpp_cmd = $self->const_cccmd;
192 $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/$cpp/;
195 '. $cpp_cmd . ' $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c > $*.i
200 $(CCCMD) -S $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
204 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
208 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.C
209 ' if !$Is_OS2 and !$Is_Win32 and !$Is_Dos; #Case-specific
212 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cpp
215 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cxx
218 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cc
225 Does very much the same as the cflags script in the perl
226 distribution. It doesn't return the whole compiler command line, but
227 initializes all of its parts. The const_cccmd method then actually
228 returns the definition of the CCCMD macro which uses these parts.
235 my($self,$libperl)=@_;
236 return $self->{CFLAGS} if $self->{CFLAGS};
237 return '' unless $self->needs_linking();
239 my($prog, $uc, $perltype, %cflags);
240 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
241 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
243 @cflags{qw(cc ccflags optimize shellflags)}
244 = @Config{qw(cc ccflags optimize shellflags)};
247 $cflags{shellflags} ||= '';
252 DE => '-DDEBUGGING -DEMBED',
253 M => '-DEMBED -DMULTIPLICITY',
254 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
257 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
260 $uc = ""; # avoid warning
262 $perltype = $map{$uc} ? $map{$uc} : "";
270 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
271 if ($prog = $Config{$name}) {
272 # Expand hints for this extension via the shell
273 print STDOUT "Processing $name hint:\n" if $Verbose;
274 my(@o)=`cc=\"$cflags{cc}\"
275 ccflags=\"$cflags{ccflags}\"
276 optimize=\"$cflags{optimize}\"
277 perltype=\"$cflags{perltype}\"
278 optdebug=\"$cflags{optdebug}\"
281 echo ccflags=\$ccflags
282 echo optimize=\$optimize
283 echo perltype=\$perltype
284 echo optdebug=\$optdebug
289 if ($line =~ /(.*?)=\s*(.*)\s*$/){
291 print STDOUT " $1 = $2\n" if $Verbose;
293 print STDOUT "Unrecognised result from hint: '$line'\n";
299 $cflags{optimize} = $optdebug;
302 for (qw(ccflags optimize perltype)) {
304 $cflags{$_} =~ s/^\s+//;
305 $cflags{$_} =~ s/\s+/ /g;
306 $cflags{$_} =~ s/\s+$//;
307 $self->{uc $_} ||= $cflags{$_};
310 if ($self->{POLLUTE}) {
311 $self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
315 if ($Config{usemymalloc} and not $Config{bincompat5005}
316 and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
317 and $self->{PERL_MALLOC_OK}) {
318 $pollute = '$(PERL_MALLOC_DEF)';
321 $self->{CCFLAGS} = quote_paren($self->{CCFLAGS});
322 $self->{OPTIMIZE} = quote_paren($self->{OPTIMIZE});
324 return $self->{CFLAGS} = qq{
325 CCFLAGS = $self->{CCFLAGS}
326 OPTIMIZE = $self->{OPTIMIZE}
327 PERLTYPE = $self->{PERLTYPE}
335 Defines the clean target.
340 # --- Cleanup and Distribution Sections ---
342 my($self, %attribs) = @_;
345 # Delete temporary files but do not touch installed files. We don\'t delete
346 # the Makefile here so a later make realclean still has a makefile to use.
350 # clean subdirectories first
351 for $dir (@{$self->{DIR}}) {
352 if ($Is_Win32 && Win32::IsWin95()) {
355 \$(TEST_F) $self->{MAKEFILE}
362 -cd $dir && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) clean
367 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
368 if ( $^O eq 'qnx' ) {
369 my @errfiles = @{$self->{C}};
373 push( @otherfiles, @errfiles, 'perlmain.err' );
375 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
376 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE)
377 $(INST_ARCHAUTODIR)/extralibs.all
378 perlmain.c tmon.out mon.out so_locations pm_to_blib
379 *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
380 $(BOOTSTRAP) $(BASEEXT).bso
381 $(BASEEXT).def lib$(BASEEXT).def
382 $(BASEEXT).exp $(BASEEXT).x
385 push(@otherfiles, qw[*.kp]);
388 push(@otherfiles, qw[core core.*perl.*.? *perl.core]);
391 push @m, "\t-$self->{RM_RF} @otherfiles\n";
392 # See realclean and ext/utils/make_ext for usage of Makefile.old
394 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
396 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
400 =item const_cccmd (o)
402 Returns the full compiler call for C programs and stores the
403 definition in CONST_CCCMD.
408 my($self,$libperl)=@_;
409 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
410 return '' unless $self->needs_linking();
411 return $self->{CONST_CCCMD} =
412 q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
413 $(CCFLAGS) $(OPTIMIZE) \\
414 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
415 $(XS_DEFINE_VERSION)};
418 =item const_config (o)
420 Defines a couple of constants in the Makefile that are imported from
426 # --- Constants Sections ---
430 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
431 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
433 foreach $m (@{$self->{CONFIG}}){
434 # SITE*EXP macros are defined in &constants; avoid duplicates here
435 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
436 $self->{uc $m} = quote_paren($self->{uc $m});
437 push @m, uc($m) , ' = ' , $self->{uc $m}, "\n";
443 =item const_loadlibs (o)
445 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
446 L<ExtUtils::Liblist> for details.
452 return "" unless $self->needs_linking;
455 # $self->{NAME} might depend on some other libraries:
456 # See ExtUtils::Liblist for details
461 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
463 next unless defined $self->{$tmp};
464 push @m, "$tmp = $self->{$tmp}\n";
471 Initializes lots of constants and .SUFFIXES and .PHONY
481 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
482 VERSION_SYM XS_VERSION INST_BIN INST_LIB
483 INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
484 INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
485 INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
486 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
487 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
488 PERL_INC PERL FULLPERL PERLRUN FULLPERLRUN PERLRUNINST
489 FULLPERLRUNINST ABSPERL ABSPERLRUN ABSPERLRUNINST
490 FULL_AR PERL_CORE NOOP NOECHO
493 next unless defined $self->{$tmp};
495 # pathnames can have sharp signs in them; escape them so
496 # make doesn't think it is a comment-start character.
497 $self->{$tmp} =~ s/#/\\#/g;
498 push @m, "$tmp = $self->{$tmp}\n";
502 VERSION_MACRO = VERSION
503 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
504 XS_VERSION_MACRO = XS_VERSION
505 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
506 PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc
510 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
511 MM_VERSION = $ExtUtils::MakeMaker::VERSION
515 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
516 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
517 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
518 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
522 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
523 LDFROM LINKTYPE PM_FILTER
525 next unless defined $self->{$tmp};
526 push @m, "$tmp = $self->{$tmp}\n";
530 # Handy lists of source code files:
531 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
532 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
533 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
534 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
535 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
536 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
540 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT
541 INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
543 next unless defined $self->{$tmp};
544 push @m, "$tmp = $self->{$tmp}\n";
551 my $method = lc($tmp);
552 # warn "self[$self] method[$method]";
553 push @m, "$tmp = ", $self->$method(), "\n";
557 .NO_CONFIG_REC: Makefile
558 } if $ENV{CLEARCASE_ROOT};
560 # why not q{} ? -- emacs
562 # work around a famous dec-osf make(1) feature(?):
565 .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc \$(OBJ_EXT)
567 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
568 # some make implementations will delete the Makefile when we rebuild it. Because
569 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
570 # does so. Our milage may vary.
571 # .PRECIOUS: Makefile # seems to be not necessary anymore
573 .PHONY: all config static dynamic test linkext manifest
575 # Where is the Config information that we are using/depend on
576 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
579 my @parentdir = split(/::/, $self->{PARENT_NAME});
581 # Where to put things:
582 INST_LIBDIR = }. File::Spec->catdir('$(INST_LIB)',@parentdir) .q{
583 INST_ARCHLIBDIR = }. File::Spec->catdir('$(INST_ARCHLIB)',@parentdir) .q{
585 INST_AUTODIR = }. File::Spec->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
586 INST_ARCHAUTODIR = }. File::Spec->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
589 if ($self->has_link_code()) {
591 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
592 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
593 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
603 $tmp = $self->export_list;
607 $tmp = $self->perl_archive;
611 $tmp = $self->perl_archive_after;
613 PERL_ARCHIVE_AFTER = $tmp
617 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
619 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
627 Same as macro for the depend attribute.
632 my($self,%attribs) = @_;
634 while (($key,$val) = each %attribs){
635 last unless defined $key;
636 push @m, "$key : $val\n";
643 Takes an array of directories that need to exist and returns a
644 Makefile entry for a .exists file in these directories. Returns
645 nothing, if the entry has already been processed. We're helpless
646 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
647 them get an entry, that's why we use "::".
652 # --- Make-Directories section (internal method) ---
653 # dir_target(@array) returns a Makefile entry for the file .exists in each
654 # named directory. Returns nothing, if the entry has already been processed.
655 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
656 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
657 # prerequisite, because there has to be one, something that doesn't change
660 my($self,@dirs) = @_;
661 my(@m,$dir,$targdir);
662 foreach $dir (@dirs) {
663 my($src) = File::Spec->catfile($self->{PERL_INC},'perl.h');
664 my($targ) = File::Spec->catfile($dir,'.exists');
665 # catfile may have adapted syntax of $dir to target OS, so...
666 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
667 ($targdir = $targ) =~ s:/?\.exists\z::;
669 else { # while elsewhere we expect to see the dir separator in $targ
670 $targdir = dirname($targ);
672 next if $self->{DIR_TARGET}{$self}{$targdir}++;
675 $self->{NOECHO}\$(MKPATH) $targdir
676 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
679 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $targdir
687 Defines a lot of macros for distribution support.
692 my($self, %attribs) = @_;
694 # VERSION should be sanitised before use as a file name
695 $attribs{VERSION} ||= '$(VERSION)';
696 $attribs{NAME} ||= '$(DISTNAME)';
697 $attribs{TAR} ||= 'tar';
698 $attribs{TARFLAGS} ||= 'cvf';
699 $attribs{ZIP} ||= 'zip';
700 $attribs{ZIPFLAGS} ||= '-r';
701 $attribs{COMPRESS} ||= 'gzip --best';
702 $attribs{SUFFIX} ||= '.gz';
703 $attribs{SHAR} ||= 'shar';
704 $attribs{PREOP} ||= "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
705 $attribs{POSTOP} ||= "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
706 $attribs{TO_UNIX} ||= "$self->{NOECHO}\$(NOOP)";
708 $attribs{CI} ||= 'ci -u';
709 $attribs{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q';
710 $attribs{DIST_CP} ||= 'best';
711 $attribs{DIST_DEFAULT} ||= 'tardist';
713 $attribs{DISTVNAME} ||= "$attribs{NAME}-$attribs{VERSION}";
715 # We've already printed out VERSION and NAME variables.
716 delete $attribs{VERSION};
717 delete $attribs{NAME};
720 while(my($var, $value) = each %attribs) {
721 $make .= "$var = $value\n";
727 =item dist_basics (o)
729 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
736 return <<'MAKE_FRAG';
737 distclean :: realclean distcheck
741 $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
744 $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
747 $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
749 veryclean : realclean
750 $(RM_F) *~ *.orig */*~ */*.orig
758 Defines a check in target for RCS.
767 $(PERLRUN) "-MExtUtils::Manifest=maniread" \\
768 -e "@all = keys %{ maniread() };" \\
769 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
770 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
777 Defines the targets dist, tardist, zipdist, uutardist, shdist
785 dist : $(DIST_DEFAULT)
786 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
787 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
789 tardist : $(DISTVNAME).tar$(SUFFIX)
791 zipdist : $(DISTVNAME).zip
793 $(DISTVNAME).tar$(SUFFIX) : distdir
796 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
797 $(RM_RF) $(DISTVNAME)
798 $(COMPRESS) $(DISTVNAME).tar
801 $(DISTVNAME).zip : distdir
803 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
804 $(RM_RF) $(DISTVNAME)
807 uutardist : $(DISTVNAME).tar$(SUFFIX)
808 uuencode $(DISTVNAME).tar$(SUFFIX) \\
809 $(DISTVNAME).tar$(SUFFIX) > \\
810 $(DISTVNAME).tar$(SUFFIX)_uu
814 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
815 $(RM_RF) $(DISTVNAME)
823 Defines the scratch directory target that will hold the distribution
824 before tar-ing (or shar-ing).
831 return <<'MAKE_FRAG';
833 $(RM_RF) $(DISTVNAME)
834 $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
835 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
843 Defines a target that produces the distribution in the
844 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
854 cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
855 cd $(DISTVNAME) && $(MAKE)
856 cd $(DISTVNAME) && $(MAKE) test
863 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
869 my($self,%attribs) = @_;
871 return '' unless ($^O eq 'aix' && $self->needs_linking() );
873 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
874 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
875 my($funclist) = $attribs{FUNCLIST} || $self->{FUNCLIST} || [];
879 dynamic :: $self->{BASEEXT}.exp
881 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
884 static :: $self->{BASEEXT}.exp
886 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
889 $self->{BASEEXT}.exp: Makefile.PL
890 ",' $(PERLRUN) -e \'use ExtUtils::Mksymlists; \\
891 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
892 neatvalue($funcs), ', "FUNCLIST" => ', neatvalue($funclist),
893 ', "DL_VARS" => ', neatvalue($vars), ');\'
901 Defines the dynamic target.
906 # --- Dynamic Loading Sections ---
910 ## $(INST_PM) has been moved to the all: target.
911 ## It remains here for awhile to allow for old usage: "make dynamic"
912 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
913 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
914 '.$self->{NOECHO}.'$(NOOP)
920 Defines targets for bootstrap files.
925 my($self, %attribs) = @_;
928 ' unless $self->has_link_code();
931 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
933 # As Mkbootstrap might not write a file (if none is required)
934 # we use touch to prevent make continually trying to remake it.
935 # The DynaLoader only reads a non-empty file.
936 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
937 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
938 '.$self->{NOECHO}.'$(PERLRUN) \
939 "-MExtUtils::Mkbootstrap" \
940 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
941 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
942 $(CHMOD) $(PERM_RW) $@
944 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
945 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
946 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
947 $(CHMOD) $(PERM_RW) $@
951 =item dynamic_lib (o)
953 Defines how to produce the *.so (or equivalent) files.
958 my($self, %attribs) = @_;
959 return '' unless $self->needs_linking(); #might be because of a subdir
961 return '' unless $self->has_link_code;
963 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
964 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
965 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
966 my($ldfrom) = '$(LDFROM)';
967 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
969 my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
971 # This section creates the dynamically loadable $(INST_DYNAMIC)
972 # from $(OBJECT) and possibly $(MYEXTLIB).
973 ARMAYBE = '.$armaybe.'
974 OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
975 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
977 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
979 if ($armaybe ne ':'){
980 $ldfrom = 'tmp$(LIB_EXT)';
981 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
982 push(@m,' $(RANLIB) '."$ldfrom\n");
984 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
986 # The IRIX linker doesn't use LD_RUN_PATH
987 my $ldrun = $^O eq 'irix' && $self->{LD_RUN_PATH} ?
988 qq{-rpath "$self->{LD_RUN_PATH}"} : '';
990 # For example in AIX the shared objects/libraries from previous builds
991 # linger quite a while in the shared dynalinker cache even when nobody
992 # is using them. This is painful if one for instance tries to restart
993 # a failed build because the link command will fail unnecessarily 'cos
994 # the shared object/library is 'busy'.
998 my $libs = $self->{LDLOADLIBS} || '';
1000 if ($^O eq 'netbsd') {
1001 # Use nothing on static perl platforms, and to the flags needed
1002 # to link against the shared libperl library on shared perl
1003 # platforms. We peek at lddlflags to see if we need -Wl,-R
1004 # or -R to add paths to the run-time library search path.
1005 if ($Config{'useshrplib'}) {
1006 if ($Config{'lddlflags'} =~ /-Wl,-R/) {
1007 $libs = '-L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -lperl';
1008 } elsif ($Config{'lddlflags'} =~ /-R/) {
1009 $libs = '-L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -lperl';
1015 ' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1016 ' $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) $(PERL_ARCHIVE) '.$libs.' $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST)');
1018 $(CHMOD) $(PERM_RWX) $@
1021 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1027 Deprecated method. Use libscan instead.
1032 my($self,$path) = @_;
1038 Called by init_others, and calls ext ExtUtils::Liblist. See
1039 L<ExtUtils::Liblist> for details.
1044 my($self,$libs) = @_;
1045 require ExtUtils::Liblist;
1046 $self->ext($libs, $Verbose);
1051 Finds the executables PERL and FULLPERL
1056 my($self, $ver, $names, $dirs, $trace) = @_;
1059 print "Looking for perl $ver by these names:
1065 foreach $name (@$names){
1066 foreach $dir (@$dirs){
1067 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1069 if (File::Spec->file_name_is_absolute($name)) { # /foo/bar
1071 } elsif (File::Spec->canonpath($name) eq File::Spec->canonpath(basename($name))) { # foo
1072 $abs = File::Spec->catfile($dir, $name);
1074 $abs = File::Spec->canonpath(File::Spec->catfile($Curdir, $name));
1076 print "Checking $abs\n" if ($trace >= 2);
1077 next unless $self->maybe_command($abs);
1078 print "Executing $abs\n" if ($trace >= 2);
1079 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1080 if ($val =~ /VER_OK/) {
1081 print "Using PERL=$abs\n" if $trace;
1083 } elsif ($trace >= 2) {
1084 print "Result: `$val'\n";
1088 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1089 0; # false and not empty
1094 =head2 Methods to actually produce chunks of text for the Makefile
1096 The methods here are called for each MakeMaker object in the order
1097 specified by @ExtUtils::MakeMaker::MM_Sections.
1105 Inserts the sharpbang or equivalent magic number to a set of @files.
1109 sub fixin { # stolen from the pink Camel book, more or less
1110 my($self, @files) = @_;
1112 my($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
1113 for my $file (@files) {
1116 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1118 chomp(my $line = <FIXIN>);
1119 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1120 # Now figure out the interpreter name.
1121 my($cmd,$arg) = split ' ', $line, 2;
1124 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1126 if ($cmd eq "perl") {
1127 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1128 $interpreter = $Config{startperl};
1129 $interpreter =~ s,^\#!,,;
1131 $interpreter = $Config{perlpath};
1134 my(@absdirs) = reverse grep {File::Spec->file_name_is_absolute} File::Spec->path;
1137 foreach $dir (@absdirs) {
1138 if ($self->maybe_command($cmd)) {
1139 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1140 $interpreter = File::Spec->catfile($dir,$cmd);
1144 # Figure out how to invoke interpreter on this machine.
1148 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1149 # this is probably value-free on DOSISH platforms
1151 $shb .= "$Config{'sharpbang'}$interpreter";
1152 $shb .= ' ' . $arg if defined $arg;
1156 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1157 if 0; # not running under some shell
1158 } unless $Is_Win32; # this won't work on win32, so don't
1160 warn "Can't find $cmd in PATH, $file unchanged"
1165 unless ( open(FIXOUT,">$file.new") ) {
1166 warn "Can't create new $file: $!\n";
1169 my($dev,$ino,$mode) = stat FIXIN;
1171 # Print out the new #! line (or equivalent).
1174 print FIXOUT $shb, <FIXIN>;
1178 unless ( rename($file, "$file.bak") ) {
1179 warn "Can't rename $file to $file.bak: $!";
1182 unless ( rename("$file.new", $file) ) {
1183 warn "Can't rename $file.new to $file: $!";
1184 unless ( rename("$file.bak", $file) ) {
1185 warn "Can't rename $file.bak back to $file either: $!";
1186 warn "Leaving $file renamed as $file.bak\n";
1192 close(FIXIN) if fileno(FIXIN);
1193 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1205 '# Phony target to force checking subdirectories.
1207 '.$self->{NOECHO}.'$(NOOP)
1213 Guess the name of this package by examining the working directory's
1214 name. MakeMaker calls this only if the developer has not supplied a
1224 my $name = basename(cwd());
1225 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we
1226 # strip minus or underline
1227 # followed by a float or some such
1228 print "Warning: Guessing NAME [$name] from current directory name.\n";
1234 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1235 object that need a compiler. Does not descend into subdirectories as
1236 needs_linking() does.
1242 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1243 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1244 $self->{HAS_LINK_CODE} = 1;
1247 return $self->{HAS_LINK_CODE} = 0;
1253 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1257 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1259 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1260 local(%pm); #the sub in find() has to see this hash
1262 @ignore{qw(Makefile.PL test.pl t)} = (1,1,1);
1264 # ignore the distdir
1265 $Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1
1266 : $ignore{$self->{DISTVNAME}} = 1;
1268 @ignore{map lc, keys %ignore} = values %ignore if $Is_VMS;
1270 foreach $name ($self->lsdir($Curdir)){
1271 next if $name =~ /\#/;
1272 next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
1273 next unless $self->libscan($name);
1275 next if -l $name; # We do not support symlinks at all
1276 $dir{$name} = $name if (-f File::Spec->catfile($name,"Makefile.PL"));
1277 } elsif ($name =~ /\.xs\z/){
1278 my($c); ($c = $name) =~ s/\.xs\z/.c/;
1281 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc
1283 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1284 } elsif ($name =~ /\.h\z/i){
1286 } elsif ($name =~ /\.PL\z/) {
1287 ($pl_files{$name} = $name) =~ s/\.PL\z// ;
1288 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) {
1289 # case-insensitive filesystem, one dot per name, so foo.h.PL
1290 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1291 local($/); open(PL,$name); my $txt = <PL>; close PL;
1292 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1293 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1296 $pm{$name} = File::Spec->catfile($self->{INST_LIBDIR},$name);
1298 } elsif ($name =~ /\.(p[ml]|pod)\z/){
1299 $pm{$name} = File::Spec->catfile($self->{INST_LIBDIR},$name);
1303 # Some larger extensions often wish to install a number of *.pm/pl
1304 # files into the library in various locations.
1306 # The attribute PMLIBDIRS holds an array reference which lists
1307 # subdirectories which we should search for library files to
1308 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1309 # recursively search through the named directories (skipping any
1310 # which don't exist or contain Makefile.PL files).
1312 # For each *.pm or *.pl file found $self->libscan() is called with
1313 # the default installation path in $_[1]. The return value of
1314 # libscan defines the actual installation location. The default
1315 # libscan function simply returns the path. The file is skipped
1316 # if libscan returns false.
1318 # The default installation location passed to libscan in $_[1] is:
1320 # ./*.pm => $(INST_LIBDIR)/*.pm
1321 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1322 # ./lib/... => $(INST_LIB)/...
1324 # In this way the 'lib' directory is seen as the root of the actual
1325 # perl library whereas the others are relative to INST_LIBDIR
1326 # (which includes PARENT_NAME). This is a subtle distinction but one
1327 # that's important for nested modules.
1329 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1330 unless $self->{PMLIBDIRS};
1332 #only existing directories that aren't in $dir are allowed
1334 # Avoid $_ wherever possible:
1335 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1336 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1338 @{$self->{PMLIBDIRS}} = ();
1339 foreach $pmlibdir (@pmlibdirs) {
1340 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1343 if (@{$self->{PMLIBDIRS}}){
1344 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1347 File::Find::find(sub {
1349 if ($_ eq "CVS" || $_ eq "RCS"){
1350 $File::Find::prune = 1;
1355 return if /~$/; # emacs temp files
1357 my $path = $File::Find::name;
1358 my $prefix = $self->{INST_LIBDIR};
1361 $prefix = $self->{INST_LIB}
1362 if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1364 my($inst) = File::Spec->catfile($prefix,$striplibpath);
1365 local($_) = $inst; # for backwards compatibility
1366 $inst = $self->libscan($inst);
1367 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1368 return unless $inst;
1370 }, @{$self->{PMLIBDIRS}});
1373 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1374 $self->{XS} = \%xs unless $self->{XS};
1375 $self->{PM} = \%pm unless $self->{PM};
1376 $self->{C} = [sort keys %c] unless $self->{C};
1377 my(@o_files) = @{$self->{C}};
1378 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files] ;
1379 $self->{H} = [sort keys %h] unless $self->{H};
1380 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1382 # Set up names of manual pages to generate from pods
1384 foreach my $man (qw(MAN1 MAN3)) {
1385 unless ($self->{"${man}PODS"}) {
1386 $self->{"${man}PODS"} = {};
1387 $pods{$man} = 1 unless
1388 $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/;
1393 if ( exists $self->{EXE_FILES} ) {
1394 foreach $name (@{$self->{EXE_FILES}}) {
1397 if (open(FH,"<$name")) {
1399 if (/^=head1\s+\w+/) {
1406 # If it doesn't exist yet, we assume, it has pods in it
1411 $self->{MAN1PODS}->{$name} =
1412 File::Spec->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1418 my %manifypods = (); # we collect the keys first, i.e. the files
1419 # we have to convert to pod
1420 foreach $name (keys %{$self->{PM}}) {
1421 if ($name =~ /\.pod\z/ ) {
1422 $manifypods{$name} = $self->{PM}{$name};
1423 } elsif ($name =~ /\.p[ml]\z/ ) {
1426 if (open(FH,"<$name")) {
1428 if (/^=head1\s+\w+/) {
1438 $manifypods{$name} = $self->{PM}{$name};
1443 # Remove "Configure.pm" and similar, if it's not the only pod listed
1444 # To force inclusion, just name it "Configure.pod", or override
1446 foreach $name (keys %manifypods) {
1447 if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) {
1448 delete $manifypods{$name};
1451 my($manpagename) = $name;
1452 $manpagename =~ s/\.p(od|m|l)\z//;
1453 unless ($manpagename =~ s!^\W*lib\W+!!s) { # everything below lib is ok
1454 $manpagename = File::Spec->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1457 $manpagename = $self->replace_manpage_separator($manpagename);
1458 $self->{MAN3PODS}->{$name} =
1459 File::Spec->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1467 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1468 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1469 INSTALL*, INSTALLDIRS, LD, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1470 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1471 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1472 VERSION_FROM, VERSION_SYM, XS_VERSION.
1479 # --- Initialize Module Name and Paths
1481 # NAME = Foo::Bar::Oracle
1482 # FULLEXT = Foo/Bar/Oracle
1484 # PARENT_NAME = Foo::Bar
1486 ### ($self->{FULLEXT} =
1487 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1488 $self->{FULLEXT} = File::Spec->catdir(split /::/, $self->{NAME});
1491 # Copied from DynaLoader:
1493 my(@modparts) = split(/::/,$self->{NAME});
1494 my($modfname) = $modparts[-1];
1496 # Some systems have restrictions on files names for DLL's etc.
1497 # mod2fname returns appropriate file base name (typically truncated)
1498 # It may also edit @modparts if required.
1499 if (defined &DynaLoader::mod2fname) {
1500 $modfname = &DynaLoader::mod2fname(\@modparts);
1503 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1504 $self->{PARENT_NAME} ||= '';
1506 if (defined &DynaLoader::mod2fname) {
1507 # As of 5.001m, dl_os2 appends '_'
1508 $self->{DLBASE} = $modfname;
1510 $self->{DLBASE} = '$(BASEEXT)';
1514 # --- Initialize PERL_LIB, PERL_SRC
1516 # *Real* information: where did we get these two from? ...
1517 my $inc_config_dir = dirname($INC{'Config.pm'});
1518 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1520 unless ($self->{PERL_SRC}){
1522 foreach $dir ($Updir,
1523 File::Spec->catdir($Updir,$Updir),
1524 File::Spec->catdir($Updir,$Updir,$Updir),
1525 File::Spec->catdir($Updir,$Updir,$Updir,$Updir),
1526 File::Spec->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1529 -f File::Spec->catfile($dir,"config_h.SH")
1531 -f File::Spec->catfile($dir,"perl.h")
1533 -f File::Spec->catfile($dir,"lib","Exporter.pm")
1535 $self->{PERL_SRC}=$dir ;
1541 warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1542 $self->{PERL_CORE} and !$self->{PERL_SRC};
1544 if ($self->{PERL_SRC}){
1545 $self->{PERL_LIB} ||= File::Spec->catdir("$self->{PERL_SRC}","lib");
1546 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1547 $self->{PERL_INC} = ($Is_Win32) ? File::Spec->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1549 # catch a situation that has occurred a few times in the past:
1551 -s File::Spec->catfile($self->{PERL_SRC},'cflags')
1555 -s File::Spec->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1562 You cannot build extensions below the perl source tree after executing
1563 a 'make clean' in the perl source tree.
1565 To rebuild extensions distributed with the perl source you should
1566 simply Configure (to include those extensions) and then build perl as
1567 normal. After installing perl the source tree can be deleted. It is
1568 not needed for building extensions by running 'perl Makefile.PL'
1569 usually without extra arguments.
1571 It is recommended that you unpack and build additional extensions away
1572 from the perl source tree.
1576 # we should also consider $ENV{PERL5LIB} here
1577 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1578 $self->{PERL_LIB} ||= $Config{privlibexp};
1579 $self->{PERL_ARCHLIB} ||= $Config{archlibexp};
1580 $self->{PERL_INC} = File::Spec->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1583 no warnings 'uninitialized' ;
1584 if (not -f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h"))
1586 # Maybe somebody tries to build an extension with an
1587 # uninstalled Perl outside of Perl build tree
1589 for my $dir (@INC) {
1590 $found = $dir, last if -e File::Spec->catdir($dir, "Config.pm");
1593 my $inc = dirname $found;
1594 if (-e File::Spec->catdir($inc, "perl.h")) {
1595 $self->{PERL_LIB} = $found;
1596 $self->{PERL_ARCHLIB} = $found;
1597 $self->{PERL_INC} = $inc;
1598 $self->{UNINSTALLED_PERL} = 1;
1600 ... Detected uninstalled Perl. Trying to continue.
1606 unless(-f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h")))
1609 Error: Unable to locate installed Perl libraries or Perl source code.
1611 It is recommended that you install perl in a standard location before
1612 building extensions. Some precompiled versions of perl do not contain
1613 these header files, so you cannot build extensions. In such a case,
1614 please build and install your perl from a fresh perl distribution. It
1615 usually solves this kind of problem.
1617 \(You get this message, because MakeMaker could not find "$perl_h"\)
1620 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1621 # if $Verbose && $self->needs_linking();
1625 # We get SITELIBEXP and SITEARCHEXP directly via
1626 # Get_from_Config. When we are running standard modules, these
1627 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1628 # set it to "site". I prefer that INSTALLDIRS be set from outside
1630 $self->{INSTALLDIRS} ||= "site";
1634 $self->init_INSTALL;
1636 $self->{MAN1EXT} ||= $Config{man1ext};
1637 $self->{MAN3EXT} ||= $Config{man3ext};
1639 # Get some stuff out of %Config if we haven't yet done so
1640 print STDOUT "CONFIG must be an array ref\n"
1641 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1642 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1643 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1644 push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1646 foreach $m (@{$self->{CONFIG}}){
1647 next if $once_only{$m};
1648 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1649 unless exists $Config{$m};
1650 $self->{uc $m} ||= $Config{$m};
1654 # This is too dangerous:
1655 # if ($^O eq "next") {
1656 # $self->{AR} = "libtool";
1657 # $self->{AR_STATIC_ARGS} = "-o";
1659 # But I leave it as a placeholder
1661 $self->{AR_STATIC_ARGS} ||= "cr";
1663 # These should never be needed
1664 $self->{LD} ||= 'ld';
1665 $self->{OBJ_EXT} ||= '.o';
1666 $self->{LIB_EXT} ||= '.a';
1668 $self->{MAP_TARGET} ||= "perl";
1670 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1672 # make a simple check if we find Exporter
1673 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1674 (Exporter.pm not found)"
1675 unless -f File::Spec->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1676 $self->{NAME} eq "ExtUtils::MakeMaker";
1678 # Determine VERSION and VERSION_FROM
1679 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1680 if ($self->{VERSION_FROM}){
1681 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1682 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1686 if ($self->{VERSION}) {
1687 $self->{VERSION} =~ s/^\s+//;
1688 $self->{VERSION} =~ s/\s+$//;
1691 $self->{VERSION} ||= "0.10";
1692 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1694 $self->{DISTVNAME} = "$self->{DISTNAME}-$self->{VERSION}";
1696 # Graham Barr and Paul Marquess had some ideas how to ensure
1697 # version compatibility between the *.pm file and the
1698 # corresponding *.xs file. The bottomline was, that we need an
1699 # XS_VERSION macro that defaults to VERSION:
1700 $self->{XS_VERSION} ||= $self->{VERSION};
1703 # --- Initialize Perl Binary Locations
1709 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1710 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1711 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1715 sub init_others { # --- Initialize Other Attributes
1718 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1719 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1720 # undefined. In any case we turn it into an anon array:
1722 # May check $Config{libs} too, thus not empty.
1723 $self->{LIBS}=[''] unless $self->{LIBS};
1725 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1726 $self->{LD_RUN_PATH} = "";
1728 foreach $libs ( @{$self->{LIBS}} ){
1729 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1730 my(@libs) = $self->extliblist($libs);
1731 if ($libs[0] or $libs[1] or $libs[2]){
1732 # LD_RUN_PATH now computed by ExtUtils::Liblist
1733 ($self->{EXTRALIBS}, $self->{BSLOADLIBS},
1734 $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1739 if ( $self->{OBJECT} ) {
1740 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1742 # init_dirscan should have found out, if we have C files
1743 $self->{OBJECT} = "";
1744 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1746 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1747 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1748 $self->{PERLMAINCC} ||= '$(CC)';
1749 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1751 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1752 # the 'dynamic' section of MM. We don't have this problem with
1753 # 'static', since we either must use it (%Config says we can't
1754 # use dynamic loading) or the caller asked for it explicitly.
1755 if (!$self->{LINKTYPE}) {
1756 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1758 : ($Config{usedl} ? 'dynamic' : 'static');
1761 # These get overridden for VMS and maybe some other systems
1762 $self->{NOOP} ||= '$(SHELL) -c true';
1763 $self->{FIRST_MAKEFILE} ||= "Makefile";
1764 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1765 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1766 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1767 $self->{RM_F} ||= "rm -f";
1768 $self->{RM_RF} ||= "rm -rf";
1769 $self->{TOUCH} ||= "touch";
1770 $self->{TEST_F} ||= "test -f";
1771 $self->{CP} ||= "cp";
1772 $self->{MV} ||= "mv";
1773 $self->{CHMOD} ||= "chmod";
1774 $self->{UMASK_NULL} ||= "umask 0";
1775 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1782 Called by init_main. Sets up all INST_* variables.
1789 $self->{INST_ARCHLIB} ||= File::Spec->catdir($Curdir,"blib","arch");
1790 $self->{INST_BIN} ||= File::Spec->catdir($Curdir,'blib','bin');
1792 # INST_LIB typically pre-set if building an extension after
1793 # perl has been built and installed. Setting INST_LIB allows
1794 # you to build directly into, say $Config{privlibexp}.
1795 unless ($self->{INST_LIB}){
1796 if ($self->{PERL_CORE}) {
1797 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1799 $self->{INST_LIB} = File::Spec->catdir($Curdir,"blib","lib");
1803 my @parentdir = split(/::/, $self->{PARENT_NAME});
1804 $self->{INST_LIBDIR} = File::Spec->catdir($self->{INST_LIB},@parentdir);
1805 $self->{INST_ARCHLIBDIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1807 $self->{INST_AUTODIR} = File::Spec->catdir($self->{INST_LIB},'auto',
1809 $self->{INST_ARCHAUTODIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1810 'auto',$self->{FULLEXT});
1812 $self->{INST_SCRIPT} ||= File::Spec->catdir($Curdir,'blib','script');
1814 $self->{INST_MAN1DIR} ||= File::Spec->catdir($Curdir,'blib','man1');
1815 $self->{INST_MAN3DIR} ||= File::Spec->catdir($Curdir,'blib','man3');
1824 Called by init_main. Sets up all INSTALL_* variables (except
1825 INSTALLDIRS) and PREFIX.
1832 # The user who requests an installation directory explicitly
1833 # should not have to tell us an architecture installation directory
1834 # as well. We look if a directory exists that is named after the
1835 # architecture. If not we take it as a sign that it should be the
1836 # same as the requested installation directory. Otherwise we take
1838 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1839 for my $libpair ({l=>"privlib", a=>"archlib"},
1840 {l=>"sitelib", a=>"sitearch"})
1842 my $lib = "install$libpair->{l}";
1844 my $Arch = uc "install$libpair->{a}";
1845 if( $self->{$Lib} && ! $self->{$Arch} ){
1846 my($ilib) = $Config{$lib};
1847 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1849 $self->prefixify($Arch,$ilib,$self->{$Lib});
1851 unless (-d $self->{$Arch}) {
1852 print STDOUT "Directory $self->{$Arch} not found\n"
1854 $self->{$Arch} = $self->{$Lib};
1856 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1860 # we have to look at the relation between $Config{prefix} and the
1861 # requested values. We're going to set the $Config{prefix} part of
1862 # all the installation path variables to literally $(PREFIX), so
1863 # the user can still say make PREFIX=foo
1864 my($configure_prefix) = $Config{'prefix'};
1865 $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1866 $self->{PREFIX} ||= $configure_prefix;
1869 my($search_prefix, $replace_prefix);
1870 # If the prefix contains perl, Configure shapes the tree as follows:
1871 # perlprefix/lib/ INSTALLPRIVLIB
1872 # perlprefix/lib/pod/
1873 # perlprefix/lib/site_perl/ INSTALLSITELIB
1874 # perlprefix/bin/ INSTALLBIN
1875 # perlprefix/man/ INSTALLMAN1DIR
1877 # prefix/lib/perl5/ INSTALLPRIVLIB
1878 # prefix/lib/perl5/pod/
1879 # prefix/lib/perl5/site_perl/ INSTALLSITELIB
1880 # prefix/bin/ INSTALLBIN
1881 # prefix/lib/perl5/man/ INSTALLMAN1DIR
1883 # The above results in various kinds of breakage on various
1884 # platforms, so we cope with it as follows: if prefix/lib/perl5
1885 # or prefix/lib/perl5/man exist, we'll replace those instead
1886 # of /prefix/{lib,man}
1888 $replace_prefix = '$(PREFIX)';
1889 for my $install_variable (qw/INSTALLBIN INSTALLSCRIPT/)
1891 $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1894 my $funkylibdir = File::Spec->catdir($configure_prefix,"lib","perl5");
1895 $funkylibdir = '' unless -d $funkylibdir;
1896 $search_prefix = $funkylibdir ||
1897 File::Spec->catdir($configure_prefix,"lib");
1900 $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1901 $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1902 File::Spec->catdir($self->{LIB},$Config{'archname'});
1905 if (-d File::Spec->catdir($self->{PREFIX},"lib","perl5")) {
1906 $replace_prefix = File::Spec->catdir(qq[\$\(PREFIX\)],"lib",
1910 $replace_prefix = File::Spec->catdir(qq[\$\(PREFIX\)],"lib");
1912 for my $install_variable (qw/
1919 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1922 my $funkymandir = File::Spec->catdir($configure_prefix,"lib","perl5","man");
1923 $funkymandir = '' unless -d $funkymandir;
1924 $search_prefix = $funkymandir || File::Spec->catdir($configure_prefix,"man");
1925 if (-d File::Spec->catdir($self->{PREFIX},"lib","perl5", "man")) {
1926 $replace_prefix = File::Spec->catdir(qq[\$\(PREFIX\)],"lib", "perl5", "man");
1929 $replace_prefix = File::Spec->catdir(qq[\$\(PREFIX\)],"man");
1931 for my $install_variable (qw/
1936 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1946 Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the
1947 *PERLRUN* permutations.
1949 PERL is allowed to be miniperl
1950 FULLPERL must be a complete perl
1951 ABSPERL is PERL converted to an absolute path
1953 *PERLRUN contains everything necessary to run perl, find it's
1956 *PERLRUNINST is *PERLRUN + everything necessary to find the
1957 modules being built.
1965 foreach my $component ($self->{PERL_SRC}, $self->path(),
1968 push @defpath, $component if defined $component;
1971 # Build up a set of file names (not command names).
1972 my $thisperl = File::Spec->canonpath($^X);
1973 $thisperl .= $Config{exe_ext} unless $thisperl =~ m/$Config{exe_ext}$/i;
1974 my @perls = ($thisperl);
1975 push @perls, map { "$_$Config{exe_ext}" }
1976 ('perl', 'perl5', "perl$Config{version}");
1978 # miniperl has priority over all but the cannonical perl when in the
1979 # core. Otherwise its a last resort.
1980 my $miniperl = "miniperl$Config{exe_ext}";
1981 if( $self->{PERL_CORE} ) {
1982 splice @perls, 1, 0, $miniperl;
1985 push @perls, $miniperl;
1989 $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
1990 # don't check if perl is executable, maybe they have decided to
1991 # supply switches with perl
1993 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1994 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1995 unless $self->{FULLPERL};
1997 # Little hack to get around VMS's find_perl putting "MCR" in front
1999 $self->{ABSPERL} = $self->{PERL};
2000 my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2001 if( File::Spec->file_name_is_absolute($self->{ABSPERL}) ) {
2002 $self->{ABSPERL} = '$(PERL)';
2005 $self->{ABSPERL} = File::Spec->rel2abs($self->{ABSPERL});
2006 $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2009 # Are we building the core?
2010 $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2012 # How do we run perl?
2013 foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2014 $self->{$perl.'RUN'} = "\$($perl)";
2016 # Make sure perl can find itself before it's installed.
2017 $self->{$perl.'RUN'} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
2018 if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2020 $self->{$perl.'RUNINST'} =
2021 sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2031 Called by init_main. Initializes PERL_*
2038 $self->{PERM_RW} = 644;
2039 $self->{PERM_RWX} = 755;
2047 Defines the install target.
2052 my($self, %attribs) = @_;
2056 install :: all pure_install doc_install
2058 install_perl :: all pure_perl_install doc_perl_install
2060 install_site :: all pure_site_install doc_site_install
2062 pure_install :: pure_$(INSTALLDIRS)_install
2064 doc_install :: doc_$(INSTALLDIRS)_install
2065 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2067 pure__install : pure_site_install
2068 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2070 doc__install : doc_site_install
2071 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2073 pure_perl_install ::
2074 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2075 read }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2076 write }.File::Spec->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2077 $(INST_LIB) $(INSTALLPRIVLIB) \
2078 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2079 $(INST_BIN) $(INSTALLBIN) \
2080 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2081 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2082 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2083 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2084 }.File::Spec->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2087 pure_site_install ::
2088 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2089 read }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2090 write }.File::Spec->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2091 $(INST_LIB) $(INSTALLSITELIB) \
2092 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2093 $(INST_BIN) $(INSTALLBIN) \
2094 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2095 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2096 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2097 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2098 }.File::Spec->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2101 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2102 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2103 "Module" "$(NAME)" \
2104 "installed into" "$(INSTALLPRIVLIB)" \
2105 LINKTYPE "$(LINKTYPE)" \
2106 VERSION "$(VERSION)" \
2107 EXE_FILES "$(EXE_FILES)" \
2108 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2111 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2112 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2113 "Module" "$(NAME)" \
2114 "installed into" "$(INSTALLSITELIB)" \
2115 LINKTYPE "$(LINKTYPE)" \
2116 VERSION "$(VERSION)" \
2117 EXE_FILES "$(EXE_FILES)" \
2118 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2123 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2125 uninstall_from_perldirs ::
2127 q{$(UNINSTALL) }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2129 uninstall_from_sitedirs ::
2131 q{$(UNINSTALL) }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2137 =item installbin (o)
2139 Defines targets to make and to install EXE_FILES.
2145 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2146 return "" unless @{$self->{EXE_FILES}};
2147 my(@m, $from, $to, %fromto, @to);
2148 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2149 for $from (@{$self->{EXE_FILES}}) {
2150 my($path)= File::Spec->catfile('$(INST_SCRIPT)', basename($from));
2151 local($_) = $path; # for backwards compatibility
2152 $to = $self->libscan($path);
2153 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2156 @to = values %fromto;
2158 EXE_FILES = @{$self->{EXE_FILES}}
2161 ? q{FIXIN = pl2bat.bat
2162 } : q{FIXIN = $(PERLRUN) "-MExtUtils::MY" \
2163 -e "MY->fixin(shift)"
2166 $self->{NOECHO}\$(NOOP)
2172 while (($from,$to) = each %fromto) {
2173 last unless defined $from;
2174 my $todir = dirname($to);
2176 $to: $from $self->{MAKEFILE} " . File::Spec->catdir($todir,'.exists') . "
2177 $self->{NOECHO}$self->{RM_F} $to
2178 $self->{CP} $from $to
2180 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2188 Takes a path to a file that is found by init_dirscan and returns false
2189 if we don't want to include this file in the library. Mainly used to
2190 exclude RCS, CVS, and SCCS directories from installation.
2197 my($self,$path) = @_;
2198 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2204 Defines the linkext target which in turn defines the LINKTYPE.
2209 my($self, %attribs) = @_;
2210 # LINKTYPE => static or dynamic or ''
2211 my($linktype) = defined $attribs{LINKTYPE} ?
2212 $attribs{LINKTYPE} : '$(LINKTYPE)';
2214 linkext :: $linktype
2215 $self->{NOECHO}\$(NOOP)
2221 Takes as arguments a directory name and a regular expression. Returns
2222 all entries in the directory that match the regular expression.
2228 my($dir, $regex) = @_;
2230 my $dh = new DirHandle;
2231 $dh->open($dir || ".") or return ();
2234 @ls = grep(/$regex/, @ls) if $regex;
2240 Simple subroutine to insert the macros defined by the macro attribute
2246 my($self,%attribs) = @_;
2248 while (($key,$val) = each %attribs){
2249 last unless defined $key;
2250 push @m, "$key = $val\n";
2257 Called by staticmake. Defines how to write the Makefile to produce a
2260 By default the Makefile produced includes all the static extensions in
2261 the perl library. (Purified versions of library files, e.g.,
2262 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2267 my($self, %attribs) = @_;
2268 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2269 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2272 # --- MakeMaker makeaperl section ---
2273 MAP_TARGET = $target
2274 FULLPERL = $self->{FULLPERL}
2276 return join '', @m if $self->{PARENT};
2278 my($dir) = join ":", @{$self->{DIR}};
2280 unless ($self->{MAKEAPERL}) {
2282 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2283 $(MAKE) -f $(MAKE_APERL_FILE) $@
2285 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2286 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2287 }.$self->{NOECHO}.q{$(PERLRUNINST) \
2288 Makefile.PL DIR=}, $dir, q{ \
2289 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2290 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2296 push @m, " \\\n\t\t$_";
2298 # push @m, map( " \\\n\t\t$_", @ARGV );
2306 my($cccmd, $linkcmd, $lperl);
2309 $cccmd = $self->const_cccmd($libperl);
2310 $cccmd =~ s/^CCCMD\s*=\s*//;
2311 $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2312 $cccmd .= " $Config{cccdlflags}"
2313 if ($Config{useshrplib} eq 'true');
2314 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2316 # The front matter of the linkcommand...
2317 $linkcmd = join ' ', "\$(CC)",
2318 grep($_, @Config{qw(ldflags ccdlflags)});
2319 $linkcmd =~ s/\s+/ /g;
2320 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2322 # Which *.a files could we make use of...
2325 File::Find::find(sub {
2326 return unless m/\Q$self->{LIB_EXT}\E$/;
2327 return if m/^libperl/;
2328 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2329 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2331 if( exists $self->{INCLUDE_EXT} ){
2336 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2340 # Throw away anything not explicitly marked for inclusion.
2341 # DynaLoader is implied.
2342 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2348 return unless $found;
2350 elsif( exists $self->{EXCLUDE_EXT} ){
2354 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2358 # Throw away anything explicitly marked for exclusion
2359 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2360 return if( $xx eq $excl );
2364 # don't include the installed version of this extension. I
2365 # leave this line here, although it is not necessary anymore:
2366 # I patched minimod.PL instead, so that Miniperl.pm won't
2367 # enclude duplicates
2369 # Once the patch to minimod.PL is in the distribution, I can
2371 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2373 $static{cwd() . "/" . $_}++;
2374 }, grep( -d $_, @{$searchdirs || []}) );
2376 # We trust that what has been handed in as argument, will be buildable
2377 $static = [] unless $static;
2378 @static{@{$static}} = (1) x @{$static};
2380 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2381 for (sort keys %static) {
2382 next unless /\Q$self->{LIB_EXT}\E\z/;
2383 $_ = dirname($_) . "/extralibs.ld";
2387 grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2392 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2393 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2394 # extralibs.all are computed correctly
2396 MAP_LINKCMD = $linkcmd
2397 MAP_PERLINC = @{$perlinc || []}
2399 join(" \\\n\t", reverse sort keys %static), "
2401 MAP_PRELIBS = $Config{perllibs} $Config{cryptlib}
2404 if (defined $libperl) {
2405 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2407 unless ($libperl && -f $lperl) { # Ilya's code...
2408 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2409 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2410 $libperl ||= "libperl$self->{LIB_EXT}";
2411 $libperl = "$dir/$libperl";
2412 $lperl ||= "libperl$self->{LIB_EXT}";
2413 $lperl = "$dir/$lperl";
2415 if (! -f $libperl and ! -f $lperl) {
2416 # We did not find a static libperl. Maybe there is a shared one?
2417 if ($^O eq 'solaris' or $^O eq 'sunos') {
2418 $lperl = $libperl = "$dir/$Config{libperl}";
2419 # SUNOS ld does not take the full path to a shared library
2420 $libperl = '' if $^O eq 'sunos';
2424 print STDOUT "Warning: $libperl not found
2425 If you're going to build a static perl binary, make sure perl is installed
2426 otherwise ignore this warning\n"
2427 unless (-f $lperl || defined($self->{PERL_SRC}));
2430 # SUNOS ld does not take the full path to a shared library
2431 my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2434 MAP_LIBPERL = $libperl
2435 LLIBPERL = $llibperl
2439 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2440 $self->{NOECHO}$self->{RM_F} \$\@
2441 $self->{NOECHO}\$(TOUCH) \$\@
2445 foreach $catfile (@$extra){
2446 push @m, "\tcat $catfile >> \$\@\n";
2450 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2451 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2452 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2453 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2454 $self->{NOECHO}echo 'To remove the intermediate files say'
2455 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2457 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2459 push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2462 $tmp/perlmain.c: $makefilename}, q{
2463 }.$self->{NOECHO}.q{echo Writing $@
2464 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2465 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2468 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2469 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2474 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2475 -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2476 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2477 "Perl binary" "$(MAP_TARGET)" \
2478 MAP_STATIC "$(MAP_STATIC)" \
2479 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2480 MAP_LIBPERL "$(MAP_LIBPERL)" \
2481 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2486 inst_perl: pure_inst_perl doc_inst_perl
2488 pure_inst_perl: $(MAP_TARGET)
2489 }.$self->{CP}.q{ $(MAP_TARGET) }.File::Spec->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2494 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2502 Defines how to rewrite the Makefile.
2509 # We do not know what target was originally specified so we
2510 # must force a manual rerun to be sure. But as it should only
2511 # happen very rarely it is not a significant problem.
2513 $(OBJECT) : $(FIRST_MAKEFILE)
2514 ' if $self->{OBJECT};
2517 # We take a very conservative approach here, but it\'s worth it.
2518 # We move Makefile to Makefile.old here to avoid gnu make looping.
2519 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2520 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2521 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2522 -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2523 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2524 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2525 $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2526 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2527 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2535 =item manifypods (o)
2537 Defines targets and routines to translate the pods into manpages and
2538 put them into the INST_* directories.
2543 my($self, %attribs) = @_;
2544 return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2545 %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2548 if (defined $self->{PERL_SRC}) {
2549 $pod2man_exe = File::Spec->catfile($self->{PERL_SRC},'pod','pod2man');
2551 $pod2man_exe = File::Spec->catfile($Config{scriptdirexp},'pod2man');
2553 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2554 # Maybe a build by uninstalled Perl?
2555 $pod2man_exe = File::Spec->catfile($self->{PERL_INC}, "pod", "pod2man");
2557 unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2558 # No pod2man but some MAN3PODS to be installed
2561 Warning: I could not locate your pod2man program. Please make sure,
2562 your pod2man program is in your PATH before you execute 'make'
2565 $pod2man_exe = "-S pod2man";
2569 qq[POD2MAN_EXE = $pod2man_exe\n],
2570 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2571 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2572 $self->{MAKEFILE}, q[";' \\
2573 -e 'print "Manifying $$m{$$_}\n";' \\
2574 -e 'system(q[$(PERLRUN) $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2575 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2577 push @m, "\nmanifypods : pure_all ";
2578 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2581 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2582 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2583 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2590 Returns true, if the argument is likely to be a command.
2595 my($self,$file) = @_;
2596 return $file if -x $file && ! -d $file;
2600 =item maybe_command_in_dirs
2602 method under development. Not yet used. Ask Ilya :-)
2606 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2607 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2608 my($self, $names, $dirs, $trace, $ver) = @_;
2610 foreach $dir (@$dirs){
2611 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2612 foreach $name (@$names){
2614 if (File::Spec->file_name_is_absolute($name)) { # /foo/bar
2616 } elsif (File::Spec->canonpath($name) eq File::Spec->canonpath(basename($name))) { # bar
2617 $abs = File::Spec->catfile($dir, $name);
2619 $abs = File::Spec->catfile($Curdir, $name);
2621 print "Checking $abs for $name\n" if ($trace >= 2);
2622 next unless $tryabs = $self->maybe_command($abs);
2623 print "Substituting $tryabs instead of $abs\n"
2624 if ($trace >= 2 and $tryabs ne $abs);
2627 print "Executing $abs\n" if ($trace >= 2);
2628 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2629 print "Using PERL=$abs\n" if $trace;
2632 } else { # Do not look for perl
2639 =item needs_linking (o)
2641 Does this module need linking? Looks into subdirectory objects (see
2642 also has_link_code())
2649 $caller = (caller(0))[3];
2650 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2651 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2652 if ($self->has_link_code or $self->{MAKEAPERL}){
2653 $self->{NEEDS_LINKING} = 1;
2656 foreach $child (keys %{$self->{CHILDREN}}) {
2657 if ($self->{CHILDREN}->{$child}->needs_linking) {
2658 $self->{NEEDS_LINKING} = 1;
2662 return $self->{NEEDS_LINKING} = 0;
2667 misnamed method (will have to be changed). The MM_Unix method just
2668 returns the argument without further processing.
2670 On VMS used to insure that colons marking targets are preceded by
2671 space - most Unix Makes don't need this, but it's necessary under VMS
2672 to distinguish the target delimiter from a colon appearing as part of
2678 my($self,$text) = @_;
2682 =item parse_abstract
2684 parse a file and return what you think is the ABSTRACT
2688 sub parse_abstract {
2689 my($self,$parsefile) = @_;
2693 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2695 my $package = $self->{DISTNAME};
2696 $package =~ s/-/::/g;
2698 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2701 next unless /^($package\s-\s)(.*)/;
2711 parse a file and return what you think is $VERSION in this file set to.
2712 It will return the string "undef" if it can't figure out what $VERSION
2713 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
2714 are okay, but my $VERSION is not.
2719 my($self,$parsefile) = @_;
2723 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2726 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2727 next if $inpod || /^\s*#/;
2729 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2730 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2732 package ExtUtils::MakeMaker::_version;
2741 $result = eval($eval);
2742 warn "Could not eval '$eval' in $parsefile: $@" if $@;
2743 $result = "undef" unless defined $result;
2753 Defines the string that is passed to recursive make calls in
2763 my($sep) = $Is_VMS ? ',' : '';
2766 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
2767 push @pasthru, "$key=\"\$($key)\"";
2770 foreach $key (qw(DEFINE INC)) {
2771 push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2774 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2780 Takes one argument, a file name, and returns the file name, if the
2781 argument is likely to be a perl script. On MM_Unix this is true for
2782 any ordinary, readable file.
2787 my($self,$file) = @_;
2788 return $file if -r $file && -f _;
2792 =item perldepend (o)
2794 Defines the dependency from all *.h files that come with the perl
2803 # Check for unpropogated config.sh changes. Should never happen.
2804 # We do NOT just update config.h because that is not sufficient.
2805 # An out of date config.h is not fatal but complains loudly!
2806 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2807 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2809 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2810 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2811 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2812 } if $self->{PERL_SRC};
2814 return join "", @m unless $self->needs_linking;
2818 $(PERL_INC)/EXTERN.h \
2819 $(PERL_INC)/INTERN.h \
2820 $(PERL_INC)/XSUB.h \
2822 $(PERL_INC)/cc_runtime.h \
2823 $(PERL_INC)/config.h \
2826 $(PERL_INC)/dosish.h \
2827 $(PERL_INC)/embed.h \
2828 $(PERL_INC)/embedvar.h \
2829 $(PERL_INC)/fakethr.h \
2830 $(PERL_INC)/form.h \
2832 $(PERL_INC)/handy.h \
2834 $(PERL_INC)/intrpvar.h \
2835 $(PERL_INC)/iperlsys.h \
2836 $(PERL_INC)/keywords.h \
2838 $(PERL_INC)/nostdio.h \
2840 $(PERL_INC)/opcode.h \
2841 $(PERL_INC)/opnames.h \
2842 $(PERL_INC)/patchlevel.h \
2843 $(PERL_INC)/perl.h \
2844 $(PERL_INC)/perlapi.h \
2845 $(PERL_INC)/perlio.h \
2846 $(PERL_INC)/perlsdio.h \
2847 $(PERL_INC)/perlsfio.h \
2848 $(PERL_INC)/perlvars.h \
2849 $(PERL_INC)/perly.h \
2851 $(PERL_INC)/pp_proto.h \
2852 $(PERL_INC)/proto.h \
2853 $(PERL_INC)/regcomp.h \
2854 $(PERL_INC)/regexp.h \
2855 $(PERL_INC)/regnodes.h \
2856 $(PERL_INC)/scope.h \
2858 $(PERL_INC)/thrdvar.h \
2859 $(PERL_INC)/thread.h \
2860 $(PERL_INC)/unixish.h \
2861 $(PERL_INC)/utf8.h \
2862 $(PERL_INC)/util.h \
2863 $(PERL_INC)/warnings.h
2865 $(OBJECT) : $(PERL_HDRS)
2866 } if $self->{OBJECT};
2868 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2876 Returns the attribute C<PERM_RW> or the string C<644>.
2877 Used as the string that is passed
2878 to the C<chmod> command to set the permissions for read/writeable files.
2879 MakeMaker chooses C<644> because it has turned out in the past that
2880 relying on the umask provokes hard-to-track bug reports.
2881 When the return value is used by the perl function C<chmod>, it is
2882 interpreted as an octal value.
2887 shift->{PERM_RW} || "644";
2892 Returns the attribute C<PERM_RWX> or the string C<755>,
2893 i.e. the string that is passed
2894 to the C<chmod> command to set the permissions for executable files.
2900 shift->{PERM_RWX} || "755";
2905 Defines target that copies all files in the hash PM to their
2906 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2910 sub _pm_to_blib_flush {
2911 my ($self, $autodir, $rr, $ra, $rl) = @_;
2913 q{ }.$self->{NOECHO}.q[$(PERLRUNINST) "-MExtUtils::Install" \
2914 -e "pm_to_blib({qw{].qq[@$ra].q[}},'].$autodir.q{','$(PM_FILTER)')"
2922 my($autodir) = File::Spec->catdir('$(INST_LIB)','auto');
2924 pm_to_blib: $(TO_INST_PM)
2926 my %pm_to_blib = %{$self->{PM}};
2929 while (my ($pm, $blib) = each %pm_to_blib) {
2930 my $la = length $pm;
2931 my $lb = length $blib;
2932 if ($l + $la + $lb + @a / 2 > 200) { # limit line length
2933 _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
2935 push @a, $pm, $blib;
2938 _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
2939 return $r.q{ }.$self->{NOECHO}.q{$(TOUCH) $@};
2942 =item post_constants (o)
2944 Returns an empty string per default. Dedicated to overrides from
2945 within Makefile.PL after all constants have been defined.
2954 =item post_initialize (o)
2956 Returns an empty string per default. Used in Makefile.PLs to add some
2957 chunk of text to the Makefile after the object is initialized.
2961 sub post_initialize {
2968 Returns an empty string. Can be used in Makefile.PLs to write some
2969 text to the Makefile at the end.
2980 Defines target that creates a PPD (Perl Package Description) file
2981 for a binary distribution.
2988 if ($self->{ABSTRACT_FROM}){
2989 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2990 Carp::carp "WARNING: Setting ABSTRACT via file ".
2991 "'$self->{ABSTRACT_FROM}' failed\n";
2994 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
2996 my $abstract = $self->{ABSTRACT} || '';
2997 $abstract =~ s/\n/\\n/sg;
2998 $abstract =~ s/</</g;
2999 $abstract =~ s/>/>/g;
3001 my $author = $self->{AUTHOR} || '';
3002 $author =~ s/</</g;
3003 $author =~ s/>/>/g;
3004 $author =~ s/@/\\@/g;
3006 my $make_ppd = sprintf <<'PPD_OUT', $pack_ver, $abstract, $author;
3007 # Creates a PPD (Perl Package Description) for a binary distribution.
3009 @$(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
3013 $make_ppd .= ' @$(PERL) -e "print qq{\t<IMPLEMENTATION>\n';
3014 foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3015 my $pre_req = $prereq;
3016 $pre_req =~ s/::/-/g;
3017 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
3019 $make_ppd .= sprintf q{\t\t<DEPENDENCY NAME=\"%s\" VERSION=\"%s\" />\n}, $pre_req, $dep_ver;
3021 $make_ppd .= qq[}" >> \$(DISTNAME).ppd\n];
3024 $make_ppd .= sprintf <<'PPD_OUT', $Config{archname};
3025 @$(PERL) -e "print qq{\t\t<OS NAME=\"$(OSNAME)\" />\n\t\t<ARCHITECTURE NAME=\"%s\" />\n
3031 if ($self->{PPM_INSTALL_SCRIPT}) {
3032 if ($self->{PPM_INSTALL_EXEC}) {
3033 $make_ppd .= sprintf q{\t\t<INSTALL EXEC=\"%s\">%s</INSTALL>\n},
3034 $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3037 $make_ppd .= sprintf q{\t\t<INSTALL>%s</INSTALL>\n},
3038 $self->{PPM_INSTALL_SCRIPT};
3042 my ($bin_location) = $self->{BINARY_LOCATION} || '';
3043 $bin_location =~ s/\\/\\\\/g;
3045 $make_ppd .= sprintf q{\t\t<CODEBASE HREF=\"%s\" />\n}, $bin_location;
3046 $make_ppd .= q{\t</IMPLEMENTATION>\n};
3047 $make_ppd .= q{</SOFTPKG>\n};
3049 $make_ppd .= '}" >> $(DISTNAME).ppd';
3056 $MM->prefixify($var, $prefix, $new_prefix, $default);
3058 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3059 replace it's $prefix with a $new_prefix. Should the $prefix fail to
3060 match it sill simply set it to the $new_prefix + $default.
3062 This is for heuristics which attempt to create directory structures
3063 that mirror those of the installed perl.
3067 $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3069 this will attempt to remove '/usr' from the front of the
3070 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3071 if necessary) and replace it with '/home/foo'. If this fails it will
3072 simply use '/home/foo/man/man1'.
3077 my($self,$var,$sprefix,$rprefix,$default) = @_;
3079 my $path = $self->{uc $var} || $Config{lc $var};
3081 print STDERR "Prefixing $var=$path\n" if $Verbose >= 2;
3082 print STDERR " from $sprefix to $rprefix\n"
3085 $path = VMS::Filespec::unixpath($path) if $Is_VMS;
3087 unless( $path =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s ) {
3089 print STDERR " cannot prefix, using default.\n" if $Verbose >= 2;
3090 print STDERR " no default!\n" if $Verbose >= 2;
3092 $path = File::Spec->catdir($rprefix, $default) if $default;
3095 print " now $path\n" if $Verbose >= 2;
3096 return $self->{uc $var} = $path;
3102 Defines targets to run *.PL files.
3108 return "" unless $self->{PL_FILES};
3110 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3111 my $list = ref($self->{PL_FILES}->{$plfile})
3112 ? $self->{PL_FILES}->{$plfile}
3113 : [$self->{PL_FILES}->{$plfile}];
3115 foreach $target (@$list) {
3118 $self->{NOECHO}\$(NOOP)
3121 \$(PERLRUNINST) $plfile $target
3130 Backslashes parentheses C<()> in command line arguments.
3131 Doesn't handle recursive Makefile C<$(...)> constructs,
3132 but handles simple ones.
3138 s/\$\((.+?)\)/\$\\\\($1\\\\)/g; # protect $(...)
3139 s/(?<!\\)([()])/\\$1/g; # quote unprotected
3140 s/\$\\\\\((.+?)\\\\\)/\$($1)/g; # unprotect $(...)
3146 Defines the realclean target.
3151 my($self, %attribs) = @_;
3155 # Delete temporary files (via clean) and also delete installed files
3156 realclean purge :: clean
3158 # realclean subdirectories first (already cleaned)
3160 if( $Is_Win32 && Win32::IsWin95() ) {
3161 $sub = <<'REALCLEAN';
3163 -$(PERLRUN) -e "exit unless -f shift; system q{$(MAKE) realclean}" %s
3168 $sub = <<'REALCLEAN';
3169 -cd %s && $(TEST_F) %s && $(MAKE) %s realclean
3173 foreach(@{$self->{DIR}}){
3174 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3175 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3177 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3178 push(@m, " $self->{RM_RF} \$(DISTVNAME)\n");
3179 if( $self->has_link_code ){
3180 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3181 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
3183 # Issue a several little RM_F commands rather than risk creating a
3184 # very long command line (useful for extensions such as Encode
3185 # that have many files).
3186 if (keys %{$self->{PM}}) {
3188 foreach (values %{$self->{PM}}) {
3189 if (length($line) + length($_) > 80) {
3190 push @m, "\t$self->{RM_F} $line\n";
3197 push @m, "\t$self->{RM_F} $line\n" if $line;
3199 my(@otherfiles) = ($self->{MAKEFILE},
3200 "$self->{MAKEFILE}.old"); # Makefiles last
3201 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3202 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
3203 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
3207 =item replace_manpage_separator
3209 my $man_name = $MM->replace_manpage_separator($file_path);
3211 Takes the name of a package, which may be a nested package, in the
3212 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3213 safe for a man page file name. Returns the replacement.
3217 sub replace_manpage_separator {
3218 my($self,$man) = @_;
3226 Defines the static target.
3231 # --- Static Loading Sections ---
3235 ## $(INST_PM) has been moved to the all: target.
3236 ## It remains here for awhile to allow for old usage: "make static"
3237 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3238 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3239 '.$self->{NOECHO}.'$(NOOP)
3243 =item static_lib (o)
3245 Defines how to produce the *.a (or equivalent) files.
3251 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3252 # return '' unless $self->needs_linking(); #might be because of a subdir
3254 return '' unless $self->has_link_code;
3258 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3261 # If this extension has its own library (eg SDBM_File)
3262 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3263 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3266 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3267 # Prefer the absolute pathed ar if available so that PATH
3268 # doesn't confuse us. Perl itself is built with the full_ar.
3274 "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3276 q{ $(CHMOD) $(PERM_RWX) $@
3277 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3279 # Old mechanism - still available:
3281 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3282 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
3285 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3289 =item staticmake (o)
3296 my($self, %attribs) = @_;
3299 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3301 # And as it's not yet built, we add the current extension
3302 # but only if it has some C code (or XS code, which implies C code)
3303 if (@{$self->{C}}) {
3304 @static = File::Spec->catfile($self->{INST_ARCHLIB},
3307 "$self->{BASEEXT}$self->{LIB_EXT}"
3311 # Either we determine now, which libraries we will produce in the
3312 # subdirectories or we do it at runtime of the make.
3314 # We could ask all subdir objects, but I cannot imagine, why it
3315 # would be necessary.
3317 # Instead we determine all libraries for the new perl at
3319 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3321 $self->makeaperl(MAKE => $self->{MAKEFILE},
3322 DIRS => \@searchdirs,
3325 TARGET => $self->{MAP_TARGET},
3327 LIBPERL => $self->{LIBPERL_A}
3333 Helper subroutine for subdirs
3338 my($self, $subdir) = @_;
3340 if ($Is_Win32 && Win32::IsWin95()) {
3341 if ($Config{'make'} =~ /dmake/i) {
3347 \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3351 } elsif ($Config{'make'} =~ /nmake/i) {
3356 \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3364 $self->{NOECHO}cd $subdir && \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3371 Defines targets to process subdirectories.
3376 # --- Sub-directory Sections ---
3379 # This method provides a mechanism to automatically deal with
3380 # subdirectories containing further Makefile.PL scripts.
3381 # It calls the subdir_x() method for each subdirectory.
3382 foreach $dir (@{$self->{DIR}}){
3383 push(@m, $self->subdir_x($dir));
3384 #### print "Including $dir subdirectory\n";
3388 # The default clean, realclean and test targets in this Makefile
3389 # have automatically been given entries for each subdir.
3393 push(@m, "\n# none")
3400 Defines the test targets.
3405 # --- Test and Installation Sections ---
3407 my($self, %attribs) = @_;
3408 my $tests = $attribs{TESTS} || '';
3409 if (!$tests && -d 't') {
3410 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3412 # note: 'test.pl' name is also hardcoded in init_dirscan()
3416 TEST_TYPE=test_\$(LINKTYPE)
3421 testdb :: testdb_\$(LINKTYPE)
3423 test :: \$(TEST_TYPE)
3426 if ($Is_Win32 && Win32::IsWin95()) {
3427 push(@m, map(qq{\t$self->{NOECHO}\$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q{\$(MAKE) test \$(PASTHRU)}" $self->{MAKEFILE}\n}, @{$self->{DIR}}));
3430 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3433 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3434 unless $tests or -f "test.pl" or @{$self->{DIR}};
3437 push(@m, "test_dynamic :: pure_all\n");
3438 push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3440 push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3444 push(@m, "testdb_dynamic :: pure_all\n");
3445 push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3449 # Occasionally we may face this degenerate target:
3450 push @m, "test_ : test_dynamic\n\n";
3452 if ($self->needs_linking()) {
3453 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3454 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3455 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3457 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3458 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3461 push @m, "test_static :: test_dynamic\n";
3462 push @m, "testdb_static :: testdb_dynamic\n";
3467 =item test_via_harness (override)
3469 For some reason which I forget, Unix machines like to have
3470 PERL_DL_NONLAZY set for tests.
3474 sub test_via_harness {
3475 my($self, $perl, $tests) = @_;
3476 return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3479 =item test_via_script (override)
3481 Again, the PERL_DL_NONLAZY thing.
3485 sub test_via_script {
3486 my($self, $perl, $script) = @_;
3487 return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3490 =item tool_autosplit (o)
3492 Defines a simple perl call that runs autosplit. May be deprecated by
3497 sub tool_autosplit {
3498 my($self, %attribs) = @_;
3500 $asl = "\$\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3502 return sprintf <<'MAKE_FRAG', $asl;
3503 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3504 AUTOSPLITFILE = $(PERLRUN) -e 'use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3510 =item tools_other (o)
3512 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3513 the Makefile. Also defines the perl programs MKPATH,
3514 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3521 my $bin_sh = $Config{sh} || '/bin/sh';
3526 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3527 push @m, "$_ = $self->{$_}\n";
3531 # The following is a portable way to say mkdir -p
3532 # To see which directories are created, change the if 0 to if 1
3533 MKPATH = $(PERLRUN) "-MExtUtils::Command" -e mkpath
3535 # This helps us to minimize the effect of the .exists files A yet
3536 # better solution would be to have a stable file in the perl
3537 # distribution with a timestamp of zero. But this solution doesn't
3538 # need any changes to the core distribution and works with older perls
3539 EQUALIZE_TIMESTAMP = $(PERLRUN) "-MExtUtils::Command" -e eqtime
3543 return join "", @m if $self->{PARENT};
3546 # Here we warn users that an old packlist file was found somewhere,
3547 # and that they should call some uninstall routine
3548 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3549 -e 'print "WARNING: I have found an old package in\n";' \\
3550 -e 'print "\t$$ARGV[0].\n";' \\
3551 -e 'print "Please make sure the two installations are not conflicting\n";'
3556 MOD_INSTALL = $(PERL) "-I$(INST_LIB)" "-I$(PERL_LIB)" "-MExtUtils::Install" \
3557 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3559 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3560 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3561 -e 'print "=over 4";' \
3562 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3565 UNINSTALL = $(PERLRUN) "-MExtUtils::Install" \
3566 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3567 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3568 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3574 =item tool_xsubpp (o)
3576 Determines typemaps, xsubpp version, prototype behaviour.
3582 return "" unless $self->needs_linking;
3583 my($xsdir) = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3584 my(@tmdeps) = File::Spec->catdir('$(XSUBPPDIR)','typemap');
3585 if( $self->{TYPEMAPS} ){
3587 foreach $typemap (@{$self->{TYPEMAPS}}){
3588 if( ! -f $typemap ){
3589 warn "Typemap $typemap not found.\n";
3592 push(@tmdeps, $typemap);
3596 push(@tmdeps, "typemap") if -f "typemap";
3597 my(@tmargs) = map("-typemap $_", @tmdeps);
3598 if( exists $self->{XSOPT} ){
3599 unshift( @tmargs, $self->{XSOPT} );
3603 my $xsubpp_version = $self->xsubpp_version(File::Spec->catfile($xsdir,"xsubpp"));
3605 # What are the correct thresholds for version 1 && 2 Paul?
3606 if ( $xsubpp_version > 1.923 ){
3607 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3609 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3610 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3611 Your version of xsubpp is $xsubpp_version and cannot handle this.
3612 Please upgrade to a more recent version of xsubpp.
3615 $self->{XSPROTOARG} = "";
3619 my $xsubpp = "xsubpp";
3623 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3624 XSPROTOARG = $self->{XSPROTOARG}
3625 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3626 XSUBPPARGS = @tmargs
3633 my($self,$xsubpp) = @_;
3634 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3638 # try to figure out the version number of the xsubpp on the system
3640 # first try the -v flag, introduced in 1.921 & 2.000a2
3642 return "" unless $self->needs_linking;
3644 my $command = qq{$self->{PERL} "-I$self->{PERL_LIB}" $xsubpp -v 2>&1};
3645 print "Running $command\n" if $Verbose >= 2;
3646 $version = `$command` ;
3647 warn "Running '$command' exits with status " . ($?>>8) if $?;
3650 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3652 # nope, then try something else
3654 my $counter = '000';
3655 my ($file) = 'temp' ;
3656 $counter++ while -e "$file$counter"; # don't overwrite anything
3659 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3661 MODULE = fred PACKAGE = fred
3670 $command = "$self->{PERL} $xsubpp $file 2>&1";
3671 print "Running $command\n" if $Verbose >= 2;
3672 my $text = `$command` ;
3673 warn "Running '$command' exits with status " . ($?>>8) if $?;
3676 # gets 1.2 -> 1.92 and 2.000a1
3677 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3679 # it is either 1.0 or 1.1
3680 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3682 # none of the above, so 1.0
3683 return $Xsubpp_Version = "1.0" ;
3686 =item top_targets (o)
3688 Defines the targets all, subdirs, config, and O_FILES
3693 # --- Target Sections ---
3699 all :: pure_all manifypods
3700 '.$self->{NOECHO}.'$(NOOP)
3702 unless $self->{SKIPHASH}{'all'};
3705 pure_all :: config pm_to_blib subdirs linkext
3706 '.$self->{NOECHO}.'$(NOOP)
3708 subdirs :: $(MYEXTLIB)
3709 '.$self->{NOECHO}.'$(NOOP)
3711 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3712 '.$self->{NOECHO}.'$(NOOP)
3714 config :: $(INST_ARCHAUTODIR)/.exists
3715 '.$self->{NOECHO}.'$(NOOP)
3717 config :: $(INST_AUTODIR)/.exists
3718 '.$self->{NOECHO}.'$(NOOP)
3721 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3723 if (%{$self->{MAN1PODS}}) {
3725 config :: \$(INST_MAN1DIR)/.exists
3726 $self->{NOECHO}\$(NOOP)
3729 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3731 if (%{$self->{MAN3PODS}}) {
3733 config :: \$(INST_MAN3DIR)/.exists
3734 $self->{NOECHO}\$(NOOP)
3737 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3741 $(O_FILES): $(H_FILES)
3742 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3746 perldoc ExtUtils::MakeMaker
3754 Obsolete, deprecated method. Not used since Version 5.21.
3759 # --- perllocal.pod section ---
3760 my($self,$what,$name,@attribs)=@_;
3761 my $time = localtime;
3762 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3763 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3764 print "\n\n=back\n\n";
3769 Defines the suffix rules to compile XS files to C.
3775 return '' unless $self->needs_linking();
3778 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3784 Defines the suffix rules to compile XS files to C++.
3790 return '' unless $self->needs_linking();
3793 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3799 Defines suffix rules to go from XS to object files directly. This is
3800 only intended for broken make implementations.
3804 sub xs_o { # many makes are too dumb to use xs_c then c_o
3806 return '' unless $self->needs_linking();
3809 $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3810 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
3816 This is internal method that returns path to libperl.a equivalent
3817 to be linked to dynamic extensions. UNIX does not have one but other
3827 =item perl_archive_after
3829 This is an internal method that returns path to a library which
3830 should be put on the linker command line I<after> the external libraries
3831 to be linked to dynamic extensions. This may be needed if the linker
3832 is one-pass, and Perl includes some overrides for C RTL functions,
3837 sub perl_archive_after
3844 This is internal method that returns name of a file that is
3845 passed to linker to define symbols to be exported.
3846 UNIX does not have one but OS2 and Win32 do.
3862 L<ExtUtils::MakeMaker>