1 package ExtUtils::MM_Unix;
5 use File::Basename qw(basename dirname fileparse);
8 use vars qw($VERSION $Is_Mac $Is_OS2 $Is_VMS $Is_Win32 $Is_Dos
9 $Verbose %pm %static $Xsubpp_Version);
11 $VERSION = substr q$Revision: 1.118 $, 10;
12 # $Id: MM_Unix.pm,v 1.118 1997/08/01 09:42:52 k Exp $
14 Exporter::import('ExtUtils::MakeMaker',
15 qw( $Verbose &neatvalue));
17 $Is_OS2 = $^O eq 'os2';
18 $Is_Mac = $^O eq 'MacOS';
19 $Is_Win32 = $^O eq 'MSWin32';
20 $Is_Dos = $^O eq 'dos';
22 if ($Is_VMS = $^O eq 'VMS') {
23 require VMS::Filespec;
24 import VMS::Filespec qw( &vmsify );
29 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
33 C<require ExtUtils::MM_Unix;>
37 The methods provided by this package are designed to be used in
38 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
39 Makefile, it creates one or more objects that inherit their methods
40 from a package C<MM>. MM itself doesn't provide any methods, but it
41 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
42 specific packages take the responsibility for all the methods provided
43 by MM_Unix. We are trying to reduce the number of the necessary
44 overrides by defining rather primitive operations within
47 If you are going to write a platform specific MM package, please try
48 to limit the necessary overrides to primitive methods, and if it is not
49 possible to do so, let's work out how to achieve that gain.
51 If you are overriding any of these methods in your Makefile.PL (in the
52 MY class), please report that to the makemaker mailing list. We are
53 trying to minimize the necessary method overrides and switch to data
54 driven Makefile.PLs wherever possible. In the long run less methods
55 will be overridable via the MY class.
59 The following description of methods is still under
60 development. Please refer to the code for not suitably documented
61 sections and complain loudly to the makemaker mailing list.
63 Not all of the methods below are overridable in a
64 Makefile.PL. Overridable methods are marked as (o). All methods are
65 overridable by a platform specific MM_*.pm file (See
66 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
68 =head2 Preloaded methods
74 No physical check on the filesystem, but a logical cleanup of a
75 path. On UNIX eliminated successive slashes and successive "/.".
81 $path =~ s|/+|/|g ; # xx////xx -> xx/xx
82 $path =~ s|(/\.)+/|/|g ; # xx/././xx -> xx/xx
83 $path =~ s|^(\./)+|| unless $path eq "./"; # ./xx -> xx
84 $path =~ s|/$|| unless $path eq "/"; # xx/ -> xx
90 Concatenate two or more directory names to form a complete path ending
91 with a directory. But remove the trailing slash from the resulting
92 string, because it doesn't look good, isn't necessary and confuses
93 OS2. Of course, if this is the root directory, don't cut off the
104 # append a slash to each argument unless it has one there
105 $_ .= "/" if $_ eq '' or substr($_,-1) ne "/";
107 my $result = join('', @args);
108 # remove a trailing slash unless we are root
109 substr($result,-1) = ""
110 if length($result) > 1 && substr($result,-1) eq "/";
116 Concatenate one or more directory names and a filename to form a
117 complete path ending with a filename
124 return $file unless @_;
125 my $dir = $self->catdir(@_);
127 $_ .= "/" unless substr($_,length($_)-1,1) eq "/";
134 Returns a string representing of the current directory. "." on UNIX.
144 Returns a string representing of the root directory. "/" on UNIX.
154 Returns a string representing of the parent directory. ".." on UNIX.
162 sub ExtUtils::MM_Unix::c_o ;
163 sub ExtUtils::MM_Unix::clean ;
164 sub ExtUtils::MM_Unix::const_cccmd ;
165 sub ExtUtils::MM_Unix::const_config ;
166 sub ExtUtils::MM_Unix::const_loadlibs ;
167 sub ExtUtils::MM_Unix::constants ;
168 sub ExtUtils::MM_Unix::depend ;
169 sub ExtUtils::MM_Unix::dir_target ;
170 sub ExtUtils::MM_Unix::dist ;
171 sub ExtUtils::MM_Unix::dist_basics ;
172 sub ExtUtils::MM_Unix::dist_ci ;
173 sub ExtUtils::MM_Unix::dist_core ;
174 sub ExtUtils::MM_Unix::dist_dir ;
175 sub ExtUtils::MM_Unix::dist_test ;
176 sub ExtUtils::MM_Unix::dlsyms ;
177 sub ExtUtils::MM_Unix::dynamic ;
178 sub ExtUtils::MM_Unix::dynamic_bs ;
179 sub ExtUtils::MM_Unix::dynamic_lib ;
180 sub ExtUtils::MM_Unix::exescan ;
181 sub ExtUtils::MM_Unix::export_list ;
182 sub ExtUtils::MM_Unix::extliblist ;
183 sub ExtUtils::MM_Unix::file_name_is_absolute ;
184 sub ExtUtils::MM_Unix::find_perl ;
185 sub ExtUtils::MM_Unix::fixin ;
186 sub ExtUtils::MM_Unix::force ;
187 sub ExtUtils::MM_Unix::guess_name ;
188 sub ExtUtils::MM_Unix::has_link_code ;
189 sub ExtUtils::MM_Unix::init_dirscan ;
190 sub ExtUtils::MM_Unix::init_main ;
191 sub ExtUtils::MM_Unix::init_others ;
192 sub ExtUtils::MM_Unix::install ;
193 sub ExtUtils::MM_Unix::installbin ;
194 sub ExtUtils::MM_Unix::libscan ;
195 sub ExtUtils::MM_Unix::linkext ;
196 sub ExtUtils::MM_Unix::lsdir ;
197 sub ExtUtils::MM_Unix::macro ;
198 sub ExtUtils::MM_Unix::makeaperl ;
199 sub ExtUtils::MM_Unix::makefile ;
200 sub ExtUtils::MM_Unix::manifypods ;
201 sub ExtUtils::MM_Unix::maybe_command ;
202 sub ExtUtils::MM_Unix::maybe_command_in_dirs ;
203 sub ExtUtils::MM_Unix::needs_linking ;
204 sub ExtUtils::MM_Unix::nicetext ;
205 sub ExtUtils::MM_Unix::parse_version ;
206 sub ExtUtils::MM_Unix::pasthru ;
207 sub ExtUtils::MM_Unix::path ;
208 sub ExtUtils::MM_Unix::perl_archive;
209 sub ExtUtils::MM_Unix::perl_script ;
210 sub ExtUtils::MM_Unix::perldepend ;
211 sub ExtUtils::MM_Unix::pm_to_blib ;
212 sub ExtUtils::MM_Unix::post_constants ;
213 sub ExtUtils::MM_Unix::post_initialize ;
214 sub ExtUtils::MM_Unix::postamble ;
215 sub ExtUtils::MM_Unix::ppd ;
216 sub ExtUtils::MM_Unix::prefixify ;
217 sub ExtUtils::MM_Unix::processPL ;
218 sub ExtUtils::MM_Unix::realclean ;
219 sub ExtUtils::MM_Unix::replace_manpage_separator ;
220 sub ExtUtils::MM_Unix::static ;
221 sub ExtUtils::MM_Unix::static_lib ;
222 sub ExtUtils::MM_Unix::staticmake ;
223 sub ExtUtils::MM_Unix::subdir_x ;
224 sub ExtUtils::MM_Unix::subdirs ;
225 sub ExtUtils::MM_Unix::test ;
226 sub ExtUtils::MM_Unix::test_via_harness ;
227 sub ExtUtils::MM_Unix::test_via_script ;
228 sub ExtUtils::MM_Unix::tool_autosplit ;
229 sub ExtUtils::MM_Unix::tool_xsubpp ;
230 sub ExtUtils::MM_Unix::tools_other ;
231 sub ExtUtils::MM_Unix::top_targets ;
232 sub ExtUtils::MM_Unix::writedoc ;
233 sub ExtUtils::MM_Unix::xs_c ;
234 sub ExtUtils::MM_Unix::xs_o ;
235 sub ExtUtils::MM_Unix::xsubpp_version ;
237 package ExtUtils::MM_Unix;
247 =head2 SelfLoaded methods
253 Defines the suffix rules to compile different flavors of C files to
259 # --- Translation Sections ---
262 return '' unless $self->needs_linking();
266 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
270 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
271 ' if $^O ne 'os2' and $^O ne 'MSWin32' and $^O ne 'dos'; #Case-specific
274 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
277 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
280 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
287 Does very much the same as the cflags script in the perl
288 distribution. It doesn't return the whole compiler command line, but
289 initializes all of its parts. The const_cccmd method then actually
290 returns the definition of the CCCMD macro which uses these parts.
297 my($self,$libperl)=@_;
298 return $self->{CFLAGS} if $self->{CFLAGS};
299 return '' unless $self->needs_linking();
301 my($prog, $uc, $perltype, %cflags);
302 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
303 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
305 @cflags{qw(cc ccflags optimize large split shellflags)}
306 = @Config{qw(cc ccflags optimize large split shellflags)};
309 $cflags{shellflags} ||= '';
314 DE => '-DDEBUGGING -DEMBED',
315 M => '-DEMBED -DMULTIPLICITY',
316 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
319 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
322 $uc = ""; # avoid warning
324 $perltype = $map{$uc} ? $map{$uc} : "";
332 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
333 if ($prog = $Config::Config{$name}) {
334 # Expand hints for this extension via the shell
335 print STDOUT "Processing $name hint:\n" if $Verbose;
336 my(@o)=`cc=\"$cflags{cc}\"
337 ccflags=\"$cflags{ccflags}\"
338 optimize=\"$cflags{optimize}\"
339 perltype=\"$cflags{perltype}\"
340 optdebug=\"$cflags{optdebug}\"
341 large=\"$cflags{large}\"
342 split=\"$cflags{'split'}\"
345 echo ccflags=\$ccflags
346 echo optimize=\$optimize
347 echo perltype=\$perltype
348 echo optdebug=\$optdebug
355 if ($line =~ /(.*?)=\s*(.*)\s*$/){
357 print STDOUT " $1 = $2\n" if $Verbose;
359 print STDOUT "Unrecognised result from hint: '$line'\n";
365 $cflags{optimize} = $optdebug;
368 for (qw(ccflags optimize perltype large split)) {
369 $cflags{$_} =~ s/^\s+//;
370 $cflags{$_} =~ s/\s+/ /g;
371 $cflags{$_} =~ s/\s+$//;
372 $self->{uc $_} ||= $cflags{$_}
375 return $self->{CFLAGS} = qq{
376 CCFLAGS = $self->{CCFLAGS}
377 OPTIMIZE = $self->{OPTIMIZE}
378 PERLTYPE = $self->{PERLTYPE}
379 LARGE = $self->{LARGE}
380 SPLIT = $self->{SPLIT}
387 Defines the clean target.
392 # --- Cleanup and Distribution Sections ---
394 my($self, %attribs) = @_;
397 # Delete temporary files but do not touch installed files. We don\'t delete
398 # the Makefile here so a later make realclean still has a makefile to use.
402 # clean subdirectories first
403 for $dir (@{$self->{DIR}}) {
404 push @m, "\t-cd $dir && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) clean\n";
407 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
408 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
409 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
410 perlmain.c mon.out core so_locations pm_to_blib
411 *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe
412 $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
415 push @m, "\t-$self->{RM_RF} @otherfiles\n";
416 # See realclean and ext/utils/make_ext for usage of Makefile.old
418 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
420 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
424 =item const_cccmd (o)
426 Returns the full compiler call for C programs and stores the
427 definition in CONST_CCCMD.
432 my($self,$libperl)=@_;
433 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
434 return '' unless $self->needs_linking();
435 return $self->{CONST_CCCMD} =
436 q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
437 $(PERLTYPE) $(LARGE) $(SPLIT) $(DEFINE_VERSION) \\
438 $(XS_DEFINE_VERSION)};
441 =item const_config (o)
443 Defines a couple of constants in the Makefile that are imported from
449 # --- Constants Sections ---
453 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
454 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
456 foreach $m (@{$self->{CONFIG}}){
457 # SITE*EXP macros are defined in &constants; avoid duplicates here
458 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
459 push @m, "\U$m\E = ".$self->{uc $m}."\n";
465 =item const_loadlibs (o)
467 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
468 L<ExtUtils::Liblist> for details.
474 return "" unless $self->needs_linking;
477 # $self->{NAME} might depend on some other libraries:
478 # See ExtUtils::Liblist for details
483 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
485 next unless defined $self->{$tmp};
486 push @m, "$tmp = $self->{$tmp}\n";
493 Initializes lots of constants and .SUFFIXES and .PHONY
503 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
504 VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
505 INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
506 INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
507 INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
508 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
509 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
510 PERL_INC PERL FULLPERL
513 next unless defined $self->{$tmp};
514 push @m, "$tmp = $self->{$tmp}\n";
518 VERSION_MACRO = VERSION
519 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
520 XS_VERSION_MACRO = XS_VERSION
521 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
525 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
526 MM_VERSION = $ExtUtils::MakeMaker::VERSION
530 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
531 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
532 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD) !!! Deprecated from MM 5.32 !!!
533 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
534 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
538 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
541 next unless defined $self->{$tmp};
542 push @m, "$tmp = $self->{$tmp}\n";
546 # Handy lists of source code files:
547 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
548 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
549 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
550 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
551 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
552 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
556 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
558 next unless defined $self->{$tmp};
559 push @m, "$tmp = $self->{$tmp}\n";
563 .NO_CONFIG_REC: Makefile
564 } if $ENV{CLEARCASE_ROOT};
566 # why not q{} ? -- emacs
568 # work around a famous dec-osf make(1) feature(?):
571 .SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
573 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
574 # some make implementations will delete the Makefile when we rebuild it. Because
575 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
576 # does so. Our milage may vary.
577 # .PRECIOUS: Makefile # seems to be not necessary anymore
579 .PHONY: all config static dynamic test linkext manifest
581 # Where is the Config information that we are using/depend on
582 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
585 my @parentdir = split(/::/, $self->{PARENT_NAME});
587 # Where to put things:
588 INST_LIBDIR = }. $self->catdir('$(INST_LIB)',@parentdir) .q{
589 INST_ARCHLIBDIR = }. $self->catdir('$(INST_ARCHLIB)',@parentdir) .q{
591 INST_AUTODIR = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
592 INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
595 if ($self->has_link_code()) {
597 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
598 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
599 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
609 $tmp = $self->export_list;
613 $tmp = $self->perl_archive;
619 #INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
621 #PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
625 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
627 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
635 Same as macro for the depend attribute.
640 my($self,%attribs) = @_;
642 while (($key,$val) = each %attribs){
643 last unless defined $key;
644 push @m, "$key: $val\n";
651 Takes an array of directories that need to exist and returns a
652 Makefile entry for a .exists file in these directories. Returns
653 nothing, if the entry has already been processed. We're helpless
654 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
655 them get an entry, that's why we use "::".
660 # --- Make-Directories section (internal method) ---
661 # dir_target(@array) returns a Makefile entry for the file .exists in each
662 # named directory. Returns nothing, if the entry has already been processed.
663 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
664 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
665 # prerequisite, because there has to be one, something that doesn't change
668 my($self,@dirs) = @_;
669 my(@m,$dir,$targdir);
670 foreach $dir (@dirs) {
671 my($src) = $self->catfile($self->{PERL_INC},'perl.h');
672 my($targ) = $self->catfile($dir,'.exists');
673 # catfile may have adapted syntax of $dir to target OS, so...
674 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
675 ($targdir = $targ) =~ s:/?\.exists$::;
677 else { # while elsewhere we expect to see the dir separator in $targ
678 $targdir = dirname($targ);
680 next if $self->{DIR_TARGET}{$self}{$targdir}++;
683 $self->{NOECHO}\$(MKPATH) $targdir
684 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
687 -$self->{NOECHO}\$(CHMOD) 755 $targdir
695 Defines a lot of macros for distribution support.
700 my($self, %attribs) = @_;
703 # VERSION should be sanitised before use as a file name
704 my($version) = $attribs{VERSION} || '$(VERSION)';
705 my($name) = $attribs{NAME} || '$(DISTNAME)';
706 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
707 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
708 my($zip) = $attribs{ZIP} || 'zip'; # eg pkzip Yuck!
709 my($zipflags) = $attribs{ZIPFLAGS} || '-r';
710 my($compress) = $attribs{COMPRESS} || 'compress'; # eg gzip
711 my($suffix) = $attribs{SUFFIX} || '.Z'; # eg .gz
712 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
713 my($preop) = $attribs{PREOP} || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
714 my($postop) = $attribs{POSTOP} || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
716 my($to_unix) = $attribs{TO_UNIX} || ($Is_OS2
718 . '$(TEST_F) tmp.zip && $(RM) tmp.zip;'
719 . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
720 : "$self->{NOECHO}\$(NOOP)");
722 my($ci) = $attribs{CI} || 'ci -u';
723 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
724 my($dist_cp) = $attribs{DIST_CP} || 'best';
725 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
728 DISTVNAME = ${name}-$version
740 RCS_LABEL = $rcs_label
742 DIST_DEFAULT = $dist_default
747 =item dist_basics (o)
749 Defines the targets distclean, distcheck, skipcheck, manifest.
757 distclean :: realclean distcheck
762 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \\
768 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \\
774 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \\
782 Defines a check in target for RCS.
791 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \\
792 -e "@all = keys %{ maniread() };" \\
793 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
794 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
801 Defeines the targets dist, tardist, zipdist, uutardist, shdist
809 dist : $(DIST_DEFAULT)
810 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
811 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
813 tardist : $(DISTVNAME).tar$(SUFFIX)
815 zipdist : $(DISTVNAME).zip
817 $(DISTVNAME).tar$(SUFFIX) : distdir
820 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
821 $(RM_RF) $(DISTVNAME)
822 $(COMPRESS) $(DISTVNAME).tar
825 $(DISTVNAME).zip : distdir
827 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
828 $(RM_RF) $(DISTVNAME)
831 uutardist : $(DISTVNAME).tar$(SUFFIX)
832 uuencode $(DISTVNAME).tar$(SUFFIX) \\
833 $(DISTVNAME).tar$(SUFFIX) > \\
834 $(DISTVNAME).tar$(SUFFIX)_uu
838 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
839 $(RM_RF) $(DISTVNAME)
847 Defines the scratch directory target that will hold the distribution
848 before tar-ing (or shar-ing).
857 $(RM_RF) $(DISTVNAME)
858 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
859 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
866 Defines a target that produces the distribution in the
867 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
877 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
878 cd $(DISTVNAME) && $(MAKE)
879 cd $(DISTVNAME) && $(MAKE) test
886 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
892 my($self,%attribs) = @_;
894 return '' unless ($^O eq 'aix' && $self->needs_linking() );
896 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
897 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
901 dynamic :: $self->{BASEEXT}.exp
903 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
906 static :: $self->{BASEEXT}.exp
908 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
911 $self->{BASEEXT}.exp: Makefile.PL
912 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
913 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
914 neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
922 Defines the dynamic target.
927 # --- Dynamic Loading Sections ---
931 ## $(INST_PM) has been moved to the all: target.
932 ## It remains here for awhile to allow for old usage: "make dynamic"
933 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
934 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
935 '.$self->{NOECHO}.'$(NOOP)
941 Defines targets for bootstrap files.
946 my($self, %attribs) = @_;
949 ' unless $self->has_link_code();
952 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
954 # As Mkbootstrap might not write a file (if none is required)
955 # we use touch to prevent make continually trying to remake it.
956 # The DynaLoader only reads a non-empty file.
957 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
958 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
959 '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
960 -MExtUtils::Mkbootstrap \
961 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
962 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
965 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
966 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
967 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
972 =item dynamic_lib (o)
974 Defines how to produce the *.so (or equivalent) files.
979 my($self, %attribs) = @_;
980 return '' unless $self->needs_linking(); #might be because of a subdir
982 return '' unless $self->has_link_code;
984 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
985 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
986 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
987 my($ldfrom) = '$(LDFROM)';
988 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
991 # This section creates the dynamically loadable $(INST_DYNAMIC)
992 # from $(OBJECT) and possibly $(MYEXTLIB).
993 ARMAYBE = '.$armaybe.'
994 OTHERLDFLAGS = '.$otherldflags.'
995 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
997 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
999 if ($armaybe ne ':'){
1000 $ldfrom = 'tmp$(LIB_EXT)';
1001 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1002 push(@m,' $(RANLIB) '."$ldfrom\n");
1004 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1006 # Brain dead solaris linker does not use LD_RUN_PATH?
1007 # This fixes dynamic extensions which need shared libs
1009 $ldrun = join ' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}
1010 if ($^O eq 'solaris');
1012 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1013 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)');
1018 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1024 Deprecated method. Use libscan instead.
1029 my($self,$path) = @_;
1035 Called by init_others, and calls ext ExtUtils::Liblist. See
1036 L<ExtUtils::Liblist> for details.
1041 my($self,$libs) = @_;
1042 require ExtUtils::Liblist;
1043 $self->ext($libs, $Verbose);
1046 =item file_name_is_absolute
1048 Takes as argument a path and returns true, if it is an absolute path.
1052 sub file_name_is_absolute {
1053 my($self,$file) = @_;
1055 $file =~ m{^([a-z]:)?[\\/]}i ;
1064 Finds the executables PERL and FULLPERL
1069 my($self, $ver, $names, $dirs, $trace) = @_;
1072 print "Looking for perl $ver by these names:
1078 foreach $dir (@$dirs){
1079 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1080 foreach $name (@$names){
1082 if ($self->file_name_is_absolute($name)) { # /foo/bar
1084 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1085 $abs = $self->catfile($dir, $name);
1087 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1089 print "Checking $abs\n" if ($trace >= 2);
1090 next unless $self->maybe_command($abs);
1091 print "Executing $abs\n" if ($trace >= 2);
1092 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1093 if ($val =~ /VER_OK/) {
1094 print "Using PERL=$abs\n" if $trace;
1096 } elsif ($trace >= 2) {
1097 print "Result: `$val'\n";
1101 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1102 0; # false and not empty
1107 =head2 Methods to actually produce chunks of text for the Makefile
1109 The methods here are called for each MakeMaker object in the order
1110 specified by @ExtUtils::MakeMaker::MM_Sections.
1116 Inserts the sharpbang or equivalent magic number to a script
1120 sub fixin { # stolen from the pink Camel book, more or less
1121 my($self,@files) = @_;
1122 my($does_shbang) = $Config::Config{'sharpbang'} =~ /^\s*\#\!/;
1123 my($file,$interpreter);
1124 for $file (@files) {
1127 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1129 chomp(my $line = <FIXIN>);
1130 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1131 # Now figure out the interpreter name.
1132 my($cmd,$arg) = split ' ', $line, 2;
1135 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1136 if ($cmd eq "perl") {
1137 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1138 $interpreter = $Config{startperl};
1139 $interpreter =~ s,^\#!,,;
1141 $interpreter = $Config{perlpath};
1144 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1147 foreach $dir (@absdirs) {
1148 if ($self->maybe_command($cmd)) {
1149 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1150 $interpreter = $self->catfile($dir,$cmd);
1154 # Figure out how to invoke interpreter on this machine.
1158 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1159 # this is probably value-free on DOSISH platforms
1161 $shb .= "$Config{'sharpbang'}$interpreter";
1162 $shb .= ' ' . $arg if defined $arg;
1166 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1167 if 0; # not running under some shell
1168 } unless $Is_Win32; # this won't work on win32, so don't
1170 warn "Can't find $cmd in PATH, $file unchanged"
1175 unless ( open(FIXOUT,">$file.new") ) {
1176 warn "Can't create new $file: $!\n";
1179 my($dev,$ino,$mode) = stat FIXIN;
1180 $mode = 0755 unless $dev;
1183 # Print out the new #! line (or equivalent).
1186 print FIXOUT $shb, <FIXIN>;
1189 # can't rename open files on some DOSISH platforms
1190 unless ( rename($file, "$file.bak") ) {
1191 warn "Can't rename $file to $file.bak: $!";
1194 unless ( rename("$file.new", $file) ) {
1195 warn "Can't rename $file.new to $file: $!";
1196 unless ( rename("$file.bak", $file) ) {
1197 warn "Can't rename $file.bak back to $file either: $!";
1198 warn "Leaving $file renamed as $file.bak\n";
1204 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
1205 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1217 '# Phony target to force checking subdirectories.
1219 '.$self->{NOECHO}.'$(NOOP)
1225 Guess the name of this package by examining the working directory's
1226 name. MakeMaker calls this only if the developer has not supplied a
1236 my $name = basename(cwd());
1237 $name =~ s|[\-_][\d\.\-]+$||; # this is new with MM 5.00, we
1238 # strip minus or underline
1239 # followed by a float or some such
1240 print "Warning: Guessing NAME [$name] from current directory name.\n";
1246 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1247 object that need a compiler. Does not descend into subdirectories as
1248 needs_linking() does.
1254 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1255 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1256 $self->{HAS_LINK_CODE} = 1;
1259 return $self->{HAS_LINK_CODE} = 0;
1264 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1268 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1270 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1271 local(%pm); #the sub in find() has to see this hash
1272 $ignore{'test.pl'} = 1;
1273 $ignore{'makefile.pl'} = 1 if $Is_VMS;
1274 foreach $name ($self->lsdir($self->curdir)){
1275 next if $name =~ /\#/;
1276 next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1277 next unless $self->libscan($name);
1279 next if -l $name; # We do not support symlinks at all
1280 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1281 } elsif ($name =~ /\.xs$/){
1282 my($c); ($c = $name) =~ s/\.xs$/.c/;
1285 } elsif ($name =~ /\.c(pp|xx|c)?$/i){ # .c .C .cpp .cxx .cc
1287 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1288 } elsif ($name =~ /\.h$/i){
1290 } elsif ($name =~ /\.(p[ml]|pod)$/){
1291 $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1292 } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
1293 ($pl_files{$name} = $name) =~ s/\.PL$// ;
1294 } elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
1295 $name ne 'test.pl') { # case-insensitive filesystem
1296 ($pl_files{$name} = $name) =~ s/\.pl$// ;
1300 # Some larger extensions often wish to install a number of *.pm/pl
1301 # files into the library in various locations.
1303 # The attribute PMLIBDIRS holds an array reference which lists
1304 # subdirectories which we should search for library files to
1305 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1306 # recursively search through the named directories (skipping any
1307 # which don't exist or contain Makefile.PL files).
1309 # For each *.pm or *.pl file found $self->libscan() is called with
1310 # the default installation path in $_[1]. The return value of
1311 # libscan defines the actual installation location. The default
1312 # libscan function simply returns the path. The file is skipped
1313 # if libscan returns false.
1315 # The default installation location passed to libscan in $_[1] is:
1317 # ./*.pm => $(INST_LIBDIR)/*.pm
1318 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1319 # ./lib/... => $(INST_LIB)/...
1321 # In this way the 'lib' directory is seen as the root of the actual
1322 # perl library whereas the others are relative to INST_LIBDIR
1323 # (which includes PARENT_NAME). This is a subtle distinction but one
1324 # that's important for nested modules.
1326 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1327 unless $self->{PMLIBDIRS};
1329 #only existing directories that aren't in $dir are allowed
1331 # Avoid $_ wherever possible:
1332 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1333 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1335 @{$self->{PMLIBDIRS}} = ();
1336 foreach $pmlibdir (@pmlibdirs) {
1337 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1340 if (@{$self->{PMLIBDIRS}}){
1341 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1344 File::Find::find(sub {
1346 if ($_ eq "CVS" || $_ eq "RCS"){
1347 $File::Find::prune = 1;
1352 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1353 my($striplibpath,$striplibname);
1354 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1355 ($striplibname,$striplibpath) = fileparse($striplibpath);
1356 my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1357 local($_) = $inst; # for backwards compatibility
1358 $inst = $self->libscan($inst);
1359 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1360 return unless $inst;
1362 }, @{$self->{PMLIBDIRS}});
1365 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1366 $self->{XS} = \%xs unless $self->{XS};
1367 $self->{PM} = \%pm unless $self->{PM};
1368 $self->{C} = [sort keys %c] unless $self->{C};
1369 my(@o_files) = @{$self->{C}};
1370 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
1371 $self->{H} = [sort keys %h] unless $self->{H};
1372 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1374 # Set up names of manual pages to generate from pods
1375 if ($self->{MAN1PODS}) {
1376 } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1377 $self->{MAN1PODS} = {};
1379 my %manifypods = ();
1380 if ( exists $self->{EXE_FILES} ) {
1381 foreach $name (@{$self->{EXE_FILES}}) {
1382 # use FileHandle ();
1383 # my $fh = new FileHandle;
1386 # if ($fh->open("<$name")) {
1387 if (open(FH,"<$name")) {
1390 if (/^=head1\s+\w+/) {
1398 # If it doesn't exist yet, we assume, it has pods in it
1402 $manifypods{$name} =
1403 $self->catfile('$(INST_MAN1DIR)',
1404 basename($name).'.$(MAN1EXT)');
1408 $self->{MAN1PODS} = \%manifypods;
1410 if ($self->{MAN3PODS}) {
1411 } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1412 $self->{MAN3PODS} = {};
1414 my %manifypods = (); # we collect the keys first, i.e. the files
1415 # we have to convert to pod
1416 foreach $name (keys %{$self->{PM}}) {
1417 if ($name =~ /\.pod$/ ) {
1418 $manifypods{$name} = $self->{PM}{$name};
1419 } elsif ($name =~ /\.p[ml]$/ ) {
1420 # use FileHandle ();
1421 # my $fh = new FileHandle;
1424 # $fh->open("<$name");
1425 if (open(FH,"<$name")) {
1428 if (/^=head1\s+\w+/) {
1439 $manifypods{$name} = $self->{PM}{$name};
1444 # Remove "Configure.pm" and similar, if it's not the only pod listed
1445 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1446 foreach $name (keys %manifypods) {
1447 if ($name =~ /(config|setup).*\.pm/i) {
1448 delete $manifypods{$name};
1451 my($manpagename) = $name;
1452 unless ($manpagename =~ s!^\W*lib\W+!!) { # everything below lib is ok
1453 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1455 $manpagename =~ s/\.p(od|m|l)$//;
1456 $manpagename = $self->replace_manpage_separator($manpagename);
1457 $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
1459 $self->{MAN3PODS} = \%manifypods;
1465 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1466 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1467 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1468 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1475 # --- Initialize Module Name and Paths
1477 # NAME = Foo::Bar::Oracle
1478 # FULLEXT = Foo/Bar/Oracle
1480 # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1481 # PARENT_NAME = Foo::Bar
1483 ### ($self->{FULLEXT} =
1484 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1485 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1488 # Copied from DynaLoader:
1490 my(@modparts) = split(/::/,$self->{NAME});
1491 my($modfname) = $modparts[-1];
1493 # Some systems have restrictions on files names for DLL's etc.
1494 # mod2fname returns appropriate file base name (typically truncated)
1495 # It may also edit @modparts if required.
1496 if (defined &DynaLoader::mod2fname) {
1497 $modfname = &DynaLoader::mod2fname(\@modparts);
1500 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!([\w:]+::)?(\w+)$! ;
1502 if (defined &DynaLoader::mod2fname) {
1503 # As of 5.001m, dl_os2 appends '_'
1504 $self->{DLBASE} = $modfname;
1506 $self->{DLBASE} = '$(BASEEXT)';
1510 ### ROOTEXT deprecated from MM 5.32
1511 ### ($self->{ROOTEXT} =
1512 ### $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
1513 ### $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1516 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1518 # *Real* information: where did we get these two from? ...
1519 my $inc_config_dir = dirname($INC{'Config.pm'});
1520 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1522 unless ($self->{PERL_SRC}){
1524 foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir())){
1526 -f $self->catfile($dir,"config.sh")
1528 -f $self->catfile($dir,"perl.h")
1530 -f $self->catfile($dir,"lib","Exporter.pm")
1532 $self->{PERL_SRC}=$dir ;
1537 if ($self->{PERL_SRC}){
1538 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1539 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1540 $self->{PERL_INC} = ($Is_Win32) ? $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1542 # catch a situation that has occurred a few times in the past:
1544 -s $self->catfile($self->{PERL_SRC},'cflags')
1548 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1555 You cannot build extensions below the perl source tree after executing
1556 a 'make clean' in the perl source tree.
1558 To rebuild extensions distributed with the perl source you should
1559 simply Configure (to include those extensions) and then build perl as
1560 normal. After installing perl the source tree can be deleted. It is
1561 not needed for building extensions by running 'perl Makefile.PL'
1562 usually without extra arguments.
1564 It is recommended that you unpack and build additional extensions away
1565 from the perl source tree.
1569 # we should also consider $ENV{PERL5LIB} here
1570 $self->{PERL_LIB} ||= $Config::Config{privlibexp};
1571 $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1572 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1574 unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1576 Error: Unable to locate installed Perl libraries or Perl source code.
1578 It is recommended that you install perl in a standard location before
1579 building extensions. Some precompiled versions of perl do not contain
1580 these header files, so you cannot build extensions. In such a case,
1581 please build and install your perl from a fresh perl distribution. It
1582 usually solves this kind of problem.
1584 \(You get this message, because MakeMaker could not find "$perl_h"\)
1587 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1588 # if $Verbose && $self->needs_linking();
1592 # We get SITELIBEXP and SITEARCHEXP directly via
1593 # Get_from_Config. When we are running standard modules, these
1594 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1595 # set it to "site". I prefer that INSTALLDIRS be set from outside
1597 $self->{INSTALLDIRS} ||= "site";
1599 # INST_LIB typically pre-set if building an extension after
1600 # perl has been built and installed. Setting INST_LIB allows
1601 # you to build directly into, say $Config::Config{privlibexp}.
1602 unless ($self->{INST_LIB}){
1605 ##### XXXXX We have to change this nonsense
1607 if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1608 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1610 $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1613 $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1614 $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1616 # We need to set up INST_LIBDIR before init_libscan() for VMS
1617 my @parentdir = split(/::/, $self->{PARENT_NAME});
1618 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1619 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1620 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1621 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1623 # INST_EXE is deprecated, should go away March '97
1624 $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1625 $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1627 # The user who requests an installation directory explicitly
1628 # should not have to tell us a architecture installation directory
1629 # as well. We look if a directory exists that is named after the
1630 # architecture. If not we take it as a sign that it should be the
1631 # same as the requested installation directory. Otherwise we take
1633 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1635 for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1636 my $lib = "install$libpair->{l}";
1638 my $Arch = uc "install$libpair->{a}";
1639 if( $self->{$Lib} && ! $self->{$Arch} ){
1640 my($ilib) = $Config{$lib};
1641 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1643 $self->prefixify($Arch,$ilib,$self->{$Lib});
1645 unless (-d $self->{$Arch}) {
1646 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1647 $self->{$Arch} = $self->{$Lib};
1649 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1653 # we have to look at the relation between $Config{prefix} and the
1654 # requested values. We're going to set the $Config{prefix} part of
1655 # all the installation path variables to literally $(PREFIX), so
1656 # the user can still say make PREFIX=foo
1657 my($configure_prefix) = $Config{'prefix'};
1658 $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1659 $self->{PREFIX} ||= $configure_prefix;
1662 my($install_variable,$search_prefix,$replace_prefix);
1664 # The rule, taken from Configure, is that if prefix contains perl,
1666 # perlprefix/lib/ INSTALLPRIVLIB
1667 # perlprefix/lib/pod/
1668 # perlprefix/lib/site_perl/ INSTALLSITELIB
1669 # perlprefix/bin/ INSTALLBIN
1670 # perlprefix/man/ INSTALLMAN1DIR
1672 # prefix/lib/perl5/ INSTALLPRIVLIB
1673 # prefix/lib/perl5/pod/
1674 # prefix/lib/perl5/site_perl/ INSTALLSITELIB
1675 # prefix/bin/ INSTALLBIN
1676 # prefix/lib/perl5/man/ INSTALLMAN1DIR
1678 $replace_prefix = qq[\$\(PREFIX\)];
1679 for $install_variable (qw/
1683 $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1685 $search_prefix = $configure_prefix =~ /perl/ ?
1686 $self->catdir($configure_prefix,"lib") :
1687 $self->catdir($configure_prefix,"lib","perl5");
1689 $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1690 $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1691 $self->catdir($self->{LIB},$Config{'archname'});
1693 $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1694 $self->catdir(qq[\$\(PREFIX\)],"lib") :
1695 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5");
1696 for $install_variable (qw/
1702 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1705 $search_prefix = $configure_prefix =~ /perl/ ?
1706 $self->catdir($configure_prefix,"man") :
1707 $self->catdir($configure_prefix,"lib","perl5","man");
1708 $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1709 $self->catdir(qq[\$\(PREFIX\)],"man") :
1710 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5","man");
1711 for $install_variable (qw/
1715 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1718 # Now we head at the manpages. Maybe they DO NOT want manpages
1720 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1721 unless defined $self->{INSTALLMAN1DIR};
1722 unless (defined $self->{INST_MAN1DIR}){
1723 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1724 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1726 $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1729 $self->{MAN1EXT} ||= $Config::Config{man1ext};
1731 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1732 unless defined $self->{INSTALLMAN3DIR};
1733 unless (defined $self->{INST_MAN3DIR}){
1734 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1735 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1737 $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1740 $self->{MAN3EXT} ||= $Config::Config{man3ext};
1743 # Get some stuff out of %Config if we haven't yet done so
1744 print STDOUT "CONFIG must be an array ref\n"
1745 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1746 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1747 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1748 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1750 foreach $m (@{$self->{CONFIG}}){
1751 next if $once_only{$m};
1752 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1753 unless exists $Config::Config{$m};
1754 $self->{uc $m} ||= $Config::Config{$m};
1758 # This is too dangerous:
1759 # if ($^O eq "next") {
1760 # $self->{AR} = "libtool";
1761 # $self->{AR_STATIC_ARGS} = "-o";
1763 # But I leave it as a placeholder
1765 $self->{AR_STATIC_ARGS} ||= "cr";
1767 # These should never be needed
1768 $self->{LD} ||= 'ld';
1769 $self->{OBJ_EXT} ||= '.o';
1770 $self->{LIB_EXT} ||= '.a';
1772 $self->{MAP_TARGET} ||= "perl";
1774 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1776 # make a simple check if we find Exporter
1777 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1778 (Exporter.pm not found)"
1779 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1780 $self->{NAME} eq "ExtUtils::MakeMaker";
1782 # Determine VERSION and VERSION_FROM
1783 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1784 if ($self->{VERSION_FROM}){
1785 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1786 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1790 if ($self->{VERSION}) {
1791 $self->{VERSION} =~ s/^\s+//;
1792 $self->{VERSION} =~ s/\s+$//;
1795 $self->{VERSION} ||= "0.10";
1796 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1799 # Graham Barr and Paul Marquess had some ideas how to ensure
1800 # version compatibility between the *.pm file and the
1801 # corresponding *.xs file. The bottomline was, that we need an
1802 # XS_VERSION macro that defaults to VERSION:
1803 $self->{XS_VERSION} ||= $self->{VERSION};
1805 # --- Initialize Perl Binary Locations
1807 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1808 # will be working versions of perl 5. miniperl has priority over perl
1809 # for PERL to ensure that $(PERL) is usable while building ./ext/*
1810 my ($component,@defpath);
1811 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1812 push @defpath, $component if defined $component;
1815 $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1816 \@defpath, $Verbose );
1817 # don't check if perl is executable, maybe they have decided to
1818 # supply switches with perl
1820 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1821 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1822 unless ($self->{FULLPERL});
1827 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1828 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1829 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1833 sub init_others { # --- Initialize Other Attributes
1836 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1837 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1838 # undefined. In any case we turn it into an anon array:
1840 # May check $Config{libs} too, thus not empty.
1841 $self->{LIBS}=[''] unless $self->{LIBS};
1843 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1844 $self->{LD_RUN_PATH} = "";
1846 foreach $libs ( @{$self->{LIBS}} ){
1847 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1848 my(@libs) = $self->extliblist($libs);
1849 if ($libs[0] or $libs[1] or $libs[2]){
1850 # LD_RUN_PATH now computed by ExtUtils::Liblist
1851 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1856 if ( $self->{OBJECT} ) {
1857 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1859 # init_dirscan should have found out, if we have C files
1860 $self->{OBJECT} = "";
1861 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1863 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1864 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1865 $self->{PERLMAINCC} ||= '$(CC)';
1866 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1868 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1869 # the 'dynamic' section of MM. We don't have this problem with
1870 # 'static', since we either must use it (%Config says we can't
1871 # use dynamic loading) or the caller asked for it explicitly.
1872 if (!$self->{LINKTYPE}) {
1873 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1875 : ($Config::Config{usedl} ? 'dynamic' : 'static');
1878 # These get overridden for VMS and maybe some other systems
1879 $self->{NOOP} ||= '$(SHELL) -c true';
1880 $self->{FIRST_MAKEFILE} ||= "Makefile";
1881 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1882 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1883 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1884 $self->{RM_F} ||= "rm -f";
1885 $self->{RM_RF} ||= "rm -rf";
1886 $self->{TOUCH} ||= "touch";
1887 $self->{TEST_F} ||= "test -f";
1888 $self->{CP} ||= "cp";
1889 $self->{MV} ||= "mv";
1890 $self->{CHMOD} ||= "chmod";
1891 $self->{UMASK_NULL} ||= "umask 0";
1892 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1897 Defines the install target.
1902 my($self, %attribs) = @_;
1906 install :: all pure_install doc_install
1908 install_perl :: all pure_perl_install doc_perl_install
1910 install_site :: all pure_site_install doc_site_install
1912 install_ :: install_site
1913 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1915 pure_install :: pure_$(INSTALLDIRS)_install
1917 doc_install :: doc_$(INSTALLDIRS)_install
1918 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
1920 pure__install : pure_site_install
1921 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1923 doc__install : doc_site_install
1924 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1926 pure_perl_install ::
1927 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1928 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1929 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1930 $(INST_LIB) $(INSTALLPRIVLIB) \
1931 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
1932 $(INST_BIN) $(INSTALLBIN) \
1933 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1934 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1935 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1936 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1937 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
1940 pure_site_install ::
1941 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1942 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
1943 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
1944 $(INST_LIB) $(INSTALLSITELIB) \
1945 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
1946 $(INST_BIN) $(INSTALLBIN) \
1947 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1948 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1949 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1950 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1951 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
1954 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1955 "Module" "$(NAME)" \
1956 "installed into" "$(INSTALLPRIVLIB)" \
1957 LINKTYPE "$(LINKTYPE)" \
1958 VERSION "$(VERSION)" \
1959 EXE_FILES "$(EXE_FILES)" \
1960 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1963 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
1964 "Module" "$(NAME)" \
1965 "installed into" "$(INSTALLSITELIB)" \
1966 LINKTYPE "$(LINKTYPE)" \
1967 VERSION "$(VERSION)" \
1968 EXE_FILES "$(EXE_FILES)" \
1969 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1974 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
1976 uninstall_from_perldirs ::
1978 q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
1980 uninstall_from_sitedirs ::
1982 q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
1988 =item installbin (o)
1990 Defines targets to install EXE_FILES.
1996 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
1997 return "" unless @{$self->{EXE_FILES}};
1998 my(@m, $from, $to, %fromto, @to);
1999 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2000 for $from (@{$self->{EXE_FILES}}) {
2001 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2002 local($_) = $path; # for backwards compatibility
2003 $to = $self->libscan($path);
2004 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2007 @to = values %fromto;
2009 EXE_FILES = @{$self->{EXE_FILES}}
2012 ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2013 -e "system qq[pl2bat.bat ].shift"
2014 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2015 -e "MY->fixin(shift)"
2018 $self->{NOECHO}\$(NOOP)
2024 while (($from,$to) = each %fromto) {
2025 last unless defined $from;
2026 my $todir = dirname($to);
2028 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2029 $self->{NOECHO}$self->{RM_F} $to
2030 $self->{CP} $from $to
2039 Takes a path to a file that is found by init_dirscan and returns false
2040 if we don't want to include this file in the library. Mainly used to
2041 exclude RCS, CVS, and SCCS directories from installation.
2048 my($self,$path) = @_;
2049 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2055 Defines the linkext target which in turn defines the LINKTYPE.
2060 my($self, %attribs) = @_;
2061 # LINKTYPE => static or dynamic or ''
2062 my($linktype) = defined $attribs{LINKTYPE} ?
2063 $attribs{LINKTYPE} : '$(LINKTYPE)';
2065 linkext :: $linktype
2066 $self->{NOECHO}\$(NOOP)
2072 Takes as arguments a directory name and a regular expression. Returns
2073 all entries in the directory that match the regular expression.
2079 my($dir, $regex) = @_;
2081 my $dh = new DirHandle;
2082 $dh->open($dir || ".") or return ();
2085 @ls = grep(/$regex/, @ls) if $regex;
2091 Simple subroutine to insert the macros defined by the macro attribute
2097 my($self,%attribs) = @_;
2099 while (($key,$val) = each %attribs){
2100 last unless defined $key;
2101 push @m, "$key = $val\n";
2108 Called by staticmake. Defines how to write the Makefile to produce a
2111 By default the Makefile produced includes all the static extensions in
2112 the perl library. (Purified versions of library files, e.g.,
2113 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2118 my($self, %attribs) = @_;
2119 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2120 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2123 # --- MakeMaker makeaperl section ---
2124 MAP_TARGET = $target
2125 FULLPERL = $self->{FULLPERL}
2127 return join '', @m if $self->{PARENT};
2129 my($dir) = join ":", @{$self->{DIR}};
2131 unless ($self->{MAKEAPERL}) {
2133 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2134 $(MAKE) -f $(MAKE_APERL_FILE) $@
2136 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2137 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2138 }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2139 Makefile.PL DIR=}, $dir, q{ \
2140 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2141 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2147 push @m, " \\\n\t\t$_";
2149 # push @m, map( " \\\n\t\t$_", @ARGV );
2157 my($cccmd, $linkcmd, $lperl);
2160 $cccmd = $self->const_cccmd($libperl);
2161 $cccmd =~ s/^CCCMD\s*=\s*//;
2162 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2163 $cccmd .= " $Config::Config{cccdlflags}"
2164 if ($Config::Config{useshrplib} eq 'true');
2165 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2167 # The front matter of the linkcommand...
2168 $linkcmd = join ' ', "\$(CC)",
2169 grep($_, @Config{qw(large split ldflags ccdlflags)});
2170 $linkcmd =~ s/\s+/ /g;
2171 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2173 # Which *.a files could we make use of...
2176 File::Find::find(sub {
2177 return unless m/\Q$self->{LIB_EXT}\E$/;
2178 return if m/^libperl/;
2179 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2180 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2182 if( exists $self->{INCLUDE_EXT} ){
2187 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2191 # Throw away anything not explicitly marked for inclusion.
2192 # DynaLoader is implied.
2193 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2199 return unless $found;
2201 elsif( exists $self->{EXCLUDE_EXT} ){
2205 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2209 # Throw away anything explicitly marked for exclusion
2210 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2211 return if( $xx eq $excl );
2215 # don't include the installed version of this extension. I
2216 # leave this line here, although it is not necessary anymore:
2217 # I patched minimod.PL instead, so that Miniperl.pm won't
2218 # enclude duplicates
2220 # Once the patch to minimod.PL is in the distribution, I can
2222 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2224 $static{cwd() . "/" . $_}++;
2225 }, grep( -d $_, @{$searchdirs || []}) );
2227 # We trust that what has been handed in as argument, will be buildable
2228 $static = [] unless $static;
2229 @static{@{$static}} = (1) x @{$static};
2231 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2232 for (sort keys %static) {
2233 next unless /\Q$self->{LIB_EXT}\E$/;
2234 $_ = dirname($_) . "/extralibs.ld";
2238 grep(s/^/-I/, @{$perlinc || []});
2240 $target = "perl" unless $target;
2241 $tmp = "." unless $tmp;
2243 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2244 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2245 # extralibs.all are computed correctly
2247 MAP_LINKCMD = $linkcmd
2248 MAP_PERLINC = @{$perlinc || []}
2250 join(" \\\n\t", reverse sort keys %static), "
2252 MAP_PRELIBS = $Config::Config{libs} $Config::Config{cryptlib}
2255 if (defined $libperl) {
2256 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2258 unless ($libperl && -f $lperl) { # Ilya's code...
2259 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2260 $libperl ||= "libperl$self->{LIB_EXT}";
2261 $libperl = "$dir/$libperl";
2262 $lperl ||= "libperl$self->{LIB_EXT}";
2263 $lperl = "$dir/$lperl";
2265 if (! -f $libperl and ! -f $lperl) {
2266 # We did not find a static libperl. Maybe there is a shared one?
2267 if ($^O eq 'solaris' or $^O eq 'sunos') {
2268 $lperl = $libperl = "$dir/$Config::Config{libperl}";
2269 # SUNOS ld does not take the full path to a shared library
2270 $libperl = '' if $^O eq 'sunos';
2274 print STDOUT "Warning: $libperl not found
2275 If you're going to build a static perl binary, make sure perl is installed
2276 otherwise ignore this warning\n"
2277 unless (-f $lperl || defined($self->{PERL_SRC}));
2281 MAP_LIBPERL = $libperl
2285 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2286 $self->{NOECHO}$self->{RM_F} \$\@
2287 $self->{NOECHO}\$(TOUCH) \$\@
2291 foreach $catfile (@$extra){
2292 push @m, "\tcat $catfile >> \$\@\n";
2294 # SUNOS ld does not take the full path to a shared library
2295 my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2297 # Brain dead solaris linker does not use LD_RUN_PATH?
2298 # This fixes dynamic extensions which need shared libs
2299 my $ldfrom = ($^O eq 'solaris')?
2300 join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2303 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2304 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom $llibperl \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2305 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2306 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2307 $self->{NOECHO}echo 'To remove the intermediate files say'
2308 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2310 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2312 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2315 $tmp/perlmain.c: $makefilename}, q{
2316 }.$self->{NOECHO}.q{echo Writing $@
2317 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2318 -e "writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)" > $@t && $(MV) $@t $@
2321 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2322 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2327 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2328 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2329 "Perl binary" "$(MAP_TARGET)" \
2330 MAP_STATIC "$(MAP_STATIC)" \
2331 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2332 MAP_LIBPERL "$(MAP_LIBPERL)" \
2333 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2338 inst_perl: pure_inst_perl doc_inst_perl
2340 pure_inst_perl: $(MAP_TARGET)
2341 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2346 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2354 Defines how to rewrite the Makefile.
2361 # We do not know what target was originally specified so we
2362 # must force a manual rerun to be sure. But as it should only
2363 # happen very rarely it is not a significant problem.
2365 $(OBJECT) : $(FIRST_MAKEFILE)
2366 ' if $self->{OBJECT};
2369 # We take a very conservative approach here, but it\'s worth it.
2370 # We move Makefile to Makefile.old here to avoid gnu make looping.
2371 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2372 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2373 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2374 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2375 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2376 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2377 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2378 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2381 # To change behavior to :: would be nice, but would break Tk b9.02
2382 # so you find such a warning below the dist target.
2383 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2384 # }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2390 =item manifypods (o)
2392 Defines targets and routines to translate the pods into manpages and
2393 put them into the INST_* directories.
2398 my($self, %attribs) = @_;
2399 return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2402 if (defined $self->{PERL_SRC}) {
2403 $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2405 $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2407 unless ($self->perl_script($pod2man_exe)) {
2408 # No pod2man but some MAN3PODS to be installed
2411 Warning: I could not locate your pod2man program. Please make sure,
2412 your pod2man program is in your PATH before you execute 'make'
2415 $pod2man_exe = "-S pod2man";
2419 qq[POD2MAN_EXE = $pod2man_exe\n],
2420 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2421 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2422 -e 'print "Manifying $$m{$$_}\n";' \\
2423 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2424 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2426 push @m, "\nmanifypods : ";
2427 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2430 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2431 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2432 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2439 Returns true, if the argument is likely to be a command.
2444 my($self,$file) = @_;
2445 return $file if -x $file && ! -d $file;
2449 =item maybe_command_in_dirs
2451 method under development. Not yet used. Ask Ilya :-)
2455 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2456 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2457 my($self, $names, $dirs, $trace, $ver) = @_;
2459 foreach $dir (@$dirs){
2460 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2461 foreach $name (@$names){
2463 if ($self->file_name_is_absolute($name)) { # /foo/bar
2465 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2466 $abs = $self->catfile($dir, $name);
2468 $abs = $self->catfile($self->curdir, $name);
2470 print "Checking $abs for $name\n" if ($trace >= 2);
2471 next unless $tryabs = $self->maybe_command($abs);
2472 print "Substituting $tryabs instead of $abs\n"
2473 if ($trace >= 2 and $tryabs ne $abs);
2476 print "Executing $abs\n" if ($trace >= 2);
2477 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2478 print "Using PERL=$abs\n" if $trace;
2481 } else { # Do not look for perl
2488 =item needs_linking (o)
2490 Does this module need linking? Looks into subdirectory objects (see
2491 also has_link_code())
2498 $caller = (caller(0))[3];
2499 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2500 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2501 if ($self->has_link_code or $self->{MAKEAPERL}){
2502 $self->{NEEDS_LINKING} = 1;
2505 foreach $child (keys %{$self->{CHILDREN}}) {
2506 if ($self->{CHILDREN}->{$child}->needs_linking) {
2507 $self->{NEEDS_LINKING} = 1;
2511 return $self->{NEEDS_LINKING} = 0;
2516 misnamed method (will have to be changed). The MM_Unix method just
2517 returns the argument without further processing.
2519 On VMS used to insure that colons marking targets are preceded by
2520 space - most Unix Makes don't need this, but it's necessary under VMS
2521 to distinguish the target delimiter from a colon appearing as part of
2527 my($self,$text) = @_;
2533 parse a file and return what you think is $VERSION in this file set to
2538 my($self,$parsefile) = @_;
2542 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2545 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2548 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2549 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2551 package ExtUtils::MakeMaker::_version;
2560 $result = eval($eval);
2561 die "Could not eval '$eval' in $parsefile: $@" if $@;
2562 $result = "undef" unless defined $result;
2569 =item parse_abstract
2571 parse a file and return what you think is the ABSTRACT
2575 sub parse_abstract {
2576 my($self,$parsefile) = @_;
2580 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2582 my $package = $self->{DISTNAME};
2583 $package =~ s/-/::/;
2585 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2588 next unless /^($package\s-\s)(.*)/;
2591 # package ExtUtils::MakeMaker::_version;
2600 # $result = eval($eval);
2601 # die "Could not eval '$eval' in $parsefile: $@" if $@;
2602 # $result = "undef" unless defined $result;
2611 Defines the string that is passed to recursive make calls in
2621 my($sep) = $Is_VMS ? ',' : '';
2624 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2625 push @pasthru, "$key=\"\$($key)\"";
2628 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2634 Takes no argument, returns the environment variable PATH as an array.
2640 my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2641 my $path = $ENV{PATH};
2642 $path =~ s:\\:/:g if $Is_OS2;
2643 my @path = split $path_sep, $path;
2644 foreach(@path) { $_ = '.' if $_ eq '' }
2650 Takes one argument, a file name, and returns the file name, if the
2651 argument is likely to be a perl script. On MM_Unix this is true for
2652 any ordinary, readable file.
2657 my($self,$file) = @_;
2658 return $file if -r $file && -f _;
2662 =item perldepend (o)
2664 Defines the dependency from all *.h files that come with the perl
2673 # Check for unpropogated config.sh changes. Should never happen.
2674 # We do NOT just update config.h because that is not sufficient.
2675 # An out of date config.h is not fatal but complains loudly!
2676 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2677 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2679 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2680 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2681 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2682 } if $self->{PERL_SRC};
2684 return join "", @m unless $self->needs_linking;
2688 $(PERL_INC)/EXTERN.h $(PERL_INC)/gv.h $(PERL_INC)/pp.h \
2689 $(PERL_INC)/INTERN.h $(PERL_INC)/handy.h $(PERL_INC)/proto.h \
2690 $(PERL_INC)/XSUB.h $(PERL_INC)/hv.h $(PERL_INC)/regcomp.h \
2691 $(PERL_INC)/av.h $(PERL_INC)/keywords.h $(PERL_INC)/regexp.h \
2692 $(PERL_INC)/config.h $(PERL_INC)/mg.h $(PERL_INC)/scope.h \
2693 $(PERL_INC)/cop.h $(PERL_INC)/op.h $(PERL_INC)/sv.h \
2694 $(PERL_INC)/cv.h $(PERL_INC)/opcode.h $(PERL_INC)/unixish.h \
2695 $(PERL_INC)/dosish.h $(PERL_INC)/patchlevel.h $(PERL_INC)/util.h \
2696 $(PERL_INC)/embed.h $(PERL_INC)/perl.h \
2697 $(PERL_INC)/form.h $(PERL_INC)/perly.h
2699 $(OBJECT) : $(PERL_HDRS)
2700 } if $self->{OBJECT};
2702 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2709 Defines target that creates a PPD (Perl Package Description) file
2710 for a binary distribution.
2717 if ($self->{ABSTRACT_FROM}){
2718 $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2719 Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n"
2721 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2722 push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2724 push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2725 push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2726 push(@m, ". qq{\\t<ABSTRACT>$self->{ABSTRACT}</ABSTRACT>\\n}");
2727 my ($author) = $self->{AUTHOR};
2728 $author =~ s/@/\\@/g;
2729 push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2730 push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2732 foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2733 my $pre_req = $prereq;
2734 $pre_req =~ s/::/-/g;
2735 push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" />\\n}");
2737 push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
2738 my ($bin_location) = $self->{BINARY_LOCATION};
2739 $bin_location =~ s/\\/\\\\/g;
2740 push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
2741 push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
2742 push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
2749 Defines target that copies all files in the hash PM to their
2750 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2756 my($autodir) = $self->catdir('$(INST_LIB)','auto');
2758 pm_to_blib: $(TO_INST_PM)
2759 }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2760 "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2761 -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2762 }.$self->{NOECHO}.q{$(TOUCH) $@
2766 =item post_constants (o)
2768 Returns an empty string per default. Dedicated to overrides from
2769 within Makefile.PL after all constants have been defined.
2778 =item post_initialize (o)
2780 Returns an empty string per default. Used in Makefile.PLs to add some
2781 chunk of text to the Makefile after the object is initialized.
2785 sub post_initialize {
2792 Returns an empty string. Can be used in Makefile.PLs to write some
2793 text to the Makefile at the end.
2804 Check a path variable in $self from %Config, if it contains a prefix,
2805 and replace it with another one.
2807 Takes as arguments an attribute name, a search prefix and a
2808 replacement prefix. Changes the attribute in the object.
2813 my($self,$var,$sprefix,$rprefix) = @_;
2814 $self->{uc $var} ||= $Config{lc $var};
2815 $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2816 $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2821 Defines targets to run *.PL files.
2827 return "" unless $self->{PL_FILES};
2829 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2831 all :: $self->{PL_FILES}->{$plfile}
2832 $self->{NOECHO}\$(NOOP)
2834 $self->{PL_FILES}->{$plfile} :: $plfile
2835 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2843 Defines the realclean target.
2848 my($self, %attribs) = @_;
2851 # Delete temporary files (via clean) and also delete installed files
2852 realclean purge :: clean
2854 # realclean subdirectories first (already cleaned)
2855 my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2856 foreach(@{$self->{DIR}}){
2857 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2858 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2860 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2861 if( $self->has_link_code ){
2862 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2863 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
2865 push(@m, " $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
2866 my(@otherfiles) = ($self->{MAKEFILE},
2867 "$self->{MAKEFILE}.old"); # Makefiles last
2868 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2869 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
2870 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
2874 =item replace_manpage_separator
2876 Takes the name of a package, which may be a nested package, in the
2877 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2881 sub replace_manpage_separator {
2882 my($self,$man) = @_;
2889 Defines the static target.
2894 # --- Static Loading Sections ---
2898 ## $(INST_PM) has been moved to the all: target.
2899 ## It remains here for awhile to allow for old usage: "make static"
2900 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2901 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2902 '.$self->{NOECHO}.'$(NOOP)
2906 =item static_lib (o)
2908 Defines how to produce the *.a (or equivalent) files.
2914 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2915 # return '' unless $self->needs_linking(); #might be because of a subdir
2917 return '' unless $self->has_link_code;
2921 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2924 # If this extension has it's own library (eg SDBM_File)
2925 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2926 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2929 q{ $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2931 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2933 # Old mechanism - still available:
2935 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2936 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
2939 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2943 =item staticmake (o)
2950 my($self, %attribs) = @_;
2953 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
2955 # And as it's not yet built, we add the current extension
2956 # but only if it has some C code (or XS code, which implies C code)
2957 if (@{$self->{C}}) {
2958 @static = $self->catfile($self->{INST_ARCHLIB},
2961 "$self->{BASEEXT}$self->{LIB_EXT}"
2965 # Either we determine now, which libraries we will produce in the
2966 # subdirectories or we do it at runtime of the make.
2968 # We could ask all subdir objects, but I cannot imagine, why it
2969 # would be necessary.
2971 # Instead we determine all libraries for the new perl at
2973 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2975 $self->makeaperl(MAKE => $self->{MAKEFILE},
2976 DIRS => \@searchdirs,
2979 TARGET => $self->{MAP_TARGET},
2981 LIBPERL => $self->{LIBPERL_A}
2987 Helper subroutine for subdirs
2992 my($self, $subdir) = @_;
2997 $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3004 Defines targets to process subdirectories.
3009 # --- Sub-directory Sections ---
3012 # This method provides a mechanism to automatically deal with
3013 # subdirectories containing further Makefile.PL scripts.
3014 # It calls the subdir_x() method for each subdirectory.
3015 foreach $dir (@{$self->{DIR}}){
3016 push(@m, $self->subdir_x($dir));
3017 #### print "Including $dir subdirectory\n";
3021 # The default clean, realclean and test targets in this Makefile
3022 # have automatically been given entries for each subdir.
3026 push(@m, "\n# none")
3033 Defines the test targets.
3038 # --- Test and Installation Sections ---
3040 my($self, %attribs) = @_;
3041 my $tests = $attribs{TESTS};
3042 if (!$tests && -d 't') {
3043 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3045 # note: 'test.pl' name is also hardcoded in init_dirscan()
3049 TEST_TYPE=test_\$(LINKTYPE)
3054 testdb :: testdb_\$(LINKTYPE)
3056 test :: \$(TEST_TYPE)
3058 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3060 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3061 unless $tests or -f "test.pl" or @{$self->{DIR}};
3064 push(@m, "test_dynamic :: pure_all\n");
3065 push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3066 push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3069 push(@m, "testdb_dynamic :: pure_all\n");
3070 push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3073 # Occasionally we may face this degenerate target:
3074 push @m, "test_ : test_dynamic\n\n";
3076 if ($self->needs_linking()) {
3077 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3078 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3079 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3081 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3082 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3085 push @m, "test_static :: test_dynamic\n";
3086 push @m, "testdb_static :: testdb_dynamic\n";
3091 =item test_via_harness (o)
3093 Helper method to write the test targets
3097 sub test_via_harness {
3098 my($self, $perl, $tests) = @_;
3099 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3100 "\t$perl".q! -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
3103 =item test_via_script (o)
3105 Other helper method for test.
3109 sub test_via_script {
3110 my($self, $perl, $script) = @_;
3111 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3112 qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3116 =item tool_autosplit (o)
3118 Defines a simple perl call that runs autosplit. May be deprecated by
3123 sub tool_autosplit {
3124 # --- Tool Sections ---
3126 my($self, %attribs) = @_;
3128 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3130 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3131 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3135 =item tools_other (o)
3137 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3138 the Makefile. Also defines the perl programs MKPATH,
3139 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3146 my $bin_sh = $Config{sh} || '/bin/sh';
3151 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3152 push @m, "$_ = $self->{$_}\n";
3156 # The following is a portable way to say mkdir -p
3157 # To see which directories are created, change the if 0 to if 1
3158 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3160 # This helps us to minimize the effect of the .exists files A yet
3161 # better solution would be to have a stable file in the perl
3162 # distribution with a timestamp of zero. But this solution doesn't
3163 # need any changes to the core distribution and works with older perls
3164 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3168 return join "", @m if $self->{PARENT};
3171 # Here we warn users that an old packlist file was found somewhere,
3172 # and that they should call some uninstall routine
3173 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3174 -e 'print "WARNING: I have found an old package in\n";' \\
3175 -e 'print "\t$$ARGV[0].\n";' \\
3176 -e 'print "Please make sure the two installations are not conflicting\n";'
3181 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3182 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3184 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3185 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3186 -e 'print "=over 4";' \
3187 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3190 UNINSTALL = $(PERL) -MExtUtils::Install \
3191 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3192 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3193 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3199 =item tool_xsubpp (o)
3201 Determines typemaps, xsubpp version, prototype behaviour.
3207 return "" unless $self->needs_linking;
3208 my($xsdir) = $self->catdir($self->{PERL_LIB},"ExtUtils");
3209 my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3210 if( $self->{TYPEMAPS} ){
3212 foreach $typemap (@{$self->{TYPEMAPS}}){
3213 if( ! -f $typemap ){
3214 warn "Typemap $typemap not found.\n";
3217 push(@tmdeps, $typemap);
3221 push(@tmdeps, "typemap") if -f "typemap";
3222 my(@tmargs) = map("-typemap $_", @tmdeps);
3223 if( exists $self->{XSOPT} ){
3224 unshift( @tmargs, $self->{XSOPT} );
3228 my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3230 # What are the correct thresholds for version 1 && 2 Paul?
3231 if ( $xsubpp_version > 1.923 ){
3232 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3234 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3235 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3236 Your version of xsubpp is $xsubpp_version and cannot handle this.
3237 Please upgrade to a more recent version of xsubpp.
3240 $self->{XSPROTOARG} = "";
3246 XSUBPP = \$(XSUBPPDIR)/xsubpp
3247 XSPROTOARG = $self->{XSPROTOARG}
3248 XSUBPPDEPS = @tmdeps
3249 XSUBPPARGS = @tmargs
3255 my($self,$xsubpp) = @_;
3256 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3260 # try to figure out the version number of the xsubpp on the system
3262 # first try the -v flag, introduced in 1.921 & 2.000a2
3264 return "" unless $self->needs_linking;
3266 my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3267 print "Running $command\n" if $Verbose >= 2;
3268 $version = `$command` ;
3269 warn "Running '$command' exits with status " . ($?>>8) if $?;
3272 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3274 # nope, then try something else
3276 my $counter = '000';
3277 my ($file) = 'temp' ;
3278 $counter++ while -e "$file$counter"; # don't overwrite anything
3281 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3283 MODULE = fred PACKAGE = fred
3292 $command = "$self->{PERL} $xsubpp $file 2>&1";
3293 print "Running $command\n" if $Verbose >= 2;
3294 my $text = `$command` ;
3295 warn "Running '$command' exits with status " . ($?>>8) if $?;
3298 # gets 1.2 -> 1.92 and 2.000a1
3299 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3301 # it is either 1.0 or 1.1
3302 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3304 # none of the above, so 1.0
3305 return $Xsubpp_Version = "1.0" ;
3308 =item top_targets (o)
3310 Defines the targets all, subdirs, config, and O_FILES
3315 # --- Target Sections ---
3320 #all :: config $(INST_PM) subdirs linkext manifypods
3324 all :: pure_all manifypods
3325 '.$self->{NOECHO}.'$(NOOP)
3327 unless $self->{SKIPHASH}{'all'};
3330 pure_all :: config pm_to_blib subdirs linkext
3331 '.$self->{NOECHO}.'$(NOOP)
3333 subdirs :: $(MYEXTLIB)
3334 '.$self->{NOECHO}.'$(NOOP)
3336 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3337 '.$self->{NOECHO}.'$(NOOP)
3339 config :: $(INST_ARCHAUTODIR)/.exists
3340 '.$self->{NOECHO}.'$(NOOP)
3342 config :: $(INST_AUTODIR)/.exists
3343 '.$self->{NOECHO}.'$(NOOP)
3347 config :: Version_check
3348 $self->{NOECHO}\$(NOOP)
3350 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3352 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3354 if (%{$self->{MAN1PODS}}) {
3356 config :: \$(INST_MAN1DIR)/.exists
3357 $self->{NOECHO}\$(NOOP)
3360 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3362 if (%{$self->{MAN3PODS}}) {
3364 config :: \$(INST_MAN3DIR)/.exists
3365 $self->{NOECHO}\$(NOOP)
3368 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3372 $(O_FILES): $(H_FILES)
3373 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3377 perldoc ExtUtils::MakeMaker
3382 }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3383 -MExtUtils::MakeMaker=Version_check \
3384 -e "Version_check('$(MM_VERSION)')"
3392 Obsolete, depecated method. Not used since Version 5.21.
3397 # --- perllocal.pod section ---
3398 my($self,$what,$name,@attribs)=@_;
3399 my $time = localtime;
3400 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3401 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3402 print "\n\n=back\n\n";
3407 Defines the suffix rules to compile XS files to C.
3413 return '' unless $self->needs_linking();
3416 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3422 Defines suffix rules to go from XS to object files directly. This is
3423 only intended for broken make implementations.
3427 sub xs_o { # many makes are too dumb to use xs_c then c_o
3429 return '' unless $self->needs_linking();
3432 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3433 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3439 This is internal method that returns path to libperl.a equivalent
3440 to be linked to dynamic extensions. UNIX does not have one but OS2
3452 This is internal method that returns name of a file that is
3453 passed to linker to define symbols to be exported.
3454 UNIX does not have one but OS2 and Win32 do.
3470 L<ExtUtils::MakeMaker>