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.126 $, 10;
12 # $Id: MM_Unix.pm,v 1.126 1998/06/28 21:32:49 k Exp k $
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 "/.".
82 if ( $^O eq 'qnx' && $path =~ s|^(//\d+)/|/| ) {
85 $path =~ s|/+|/|g ; # xx////xx -> xx/xx
86 $path =~ s|(/\.)+/|/|g ; # xx/././xx -> xx/xx
87 $path =~ s|^(\./)+|| unless $path eq "./"; # ./xx -> xx
88 $path =~ s|/$|| unless $path eq "/"; # xx/ -> xx
94 Concatenate two or more directory names to form a complete path ending
95 with a directory. But remove the trailing slash from the resulting
96 string, because it doesn't look good, isn't necessary and confuses
97 OS2. Of course, if this is the root directory, don't cut off the
108 # append a slash to each argument unless it has one there
109 $_ .= "/" if $_ eq '' or substr($_,-1) ne "/";
111 $self->canonpath(join('', @args));
116 Concatenate one or more directory names and a filename to form a
117 complete path ending with a filename
124 return $self->canonpath($file) unless @_;
125 my $dir = $self->catdir(@_);
127 $_ .= "/" unless substr($_,length($_)-1,1) eq "/";
129 return $self->canonpath($dir.$file);
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::prefixify ;
216 sub ExtUtils::MM_Unix::processPL ;
217 sub ExtUtils::MM_Unix::realclean ;
218 sub ExtUtils::MM_Unix::replace_manpage_separator ;
219 sub ExtUtils::MM_Unix::static ;
220 sub ExtUtils::MM_Unix::static_lib ;
221 sub ExtUtils::MM_Unix::staticmake ;
222 sub ExtUtils::MM_Unix::subdir_x ;
223 sub ExtUtils::MM_Unix::subdirs ;
224 sub ExtUtils::MM_Unix::test ;
225 sub ExtUtils::MM_Unix::test_via_harness ;
226 sub ExtUtils::MM_Unix::test_via_script ;
227 sub ExtUtils::MM_Unix::tool_autosplit ;
228 sub ExtUtils::MM_Unix::tool_xsubpp ;
229 sub ExtUtils::MM_Unix::tools_other ;
230 sub ExtUtils::MM_Unix::top_targets ;
231 sub ExtUtils::MM_Unix::writedoc ;
232 sub ExtUtils::MM_Unix::xs_c ;
233 sub ExtUtils::MM_Unix::xs_o ;
234 sub ExtUtils::MM_Unix::xsubpp_version ;
236 package ExtUtils::MM_Unix;
246 =head2 SelfLoaded methods
252 Defines the suffix rules to compile different flavors of C files to
258 # --- Translation Sections ---
261 return '' unless $self->needs_linking();
265 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
269 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
270 ' if $^O ne 'os2' and $^O ne 'MSWin32' and $^O ne 'dos'; #Case-specific
273 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
276 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
279 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
286 Does very much the same as the cflags script in the perl
287 distribution. It doesn't return the whole compiler command line, but
288 initializes all of its parts. The const_cccmd method then actually
289 returns the definition of the CCCMD macro which uses these parts.
296 my($self,$libperl)=@_;
297 return $self->{CFLAGS} if $self->{CFLAGS};
298 return '' unless $self->needs_linking();
300 my($prog, $uc, $perltype, %cflags);
301 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
302 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
304 @cflags{qw(cc ccflags optimize large split shellflags)}
305 = @Config{qw(cc ccflags optimize large split shellflags)};
308 $cflags{shellflags} ||= '';
313 DE => '-DDEBUGGING -DEMBED',
314 M => '-DEMBED -DMULTIPLICITY',
315 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
318 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
321 $uc = ""; # avoid warning
323 $perltype = $map{$uc} ? $map{$uc} : "";
331 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
332 if ($prog = $Config::Config{$name}) {
333 # Expand hints for this extension via the shell
334 print STDOUT "Processing $name hint:\n" if $Verbose;
335 my(@o)=`cc=\"$cflags{cc}\"
336 ccflags=\"$cflags{ccflags}\"
337 optimize=\"$cflags{optimize}\"
338 perltype=\"$cflags{perltype}\"
339 optdebug=\"$cflags{optdebug}\"
340 large=\"$cflags{large}\"
341 split=\"$cflags{'split'}\"
344 echo ccflags=\$ccflags
345 echo optimize=\$optimize
346 echo perltype=\$perltype
347 echo optdebug=\$optdebug
354 if ($line =~ /(.*?)=\s*(.*)\s*$/){
356 print STDOUT " $1 = $2\n" if $Verbose;
358 print STDOUT "Unrecognised result from hint: '$line'\n";
364 $cflags{optimize} = $optdebug;
367 for (qw(ccflags optimize perltype large split)) {
368 $cflags{$_} =~ s/^\s+//;
369 $cflags{$_} =~ s/\s+/ /g;
370 $cflags{$_} =~ s/\s+$//;
371 $self->{uc $_} ||= $cflags{$_}
375 $self->{CCFLAGS} =~ s/-DPERL_OBJECT(\s|$)//;
376 $self->{CCFLAGS} .= '-DPERL_CAPI';
377 if ($Is_Win32 && $Config{'cc'} =~ /^cl.exe/i) {
378 # Turn off C++ mode of the MSC compiler
379 $self->{CCFLAGS} =~ s/-TP(\s|$)//;
380 $self->{OPTIMIZE} =~ s/-TP(\s|$)//;
383 return $self->{CFLAGS} = qq{
384 CCFLAGS = $self->{CCFLAGS}
385 OPTIMIZE = $self->{OPTIMIZE}
386 PERLTYPE = $self->{PERLTYPE}
387 LARGE = $self->{LARGE}
388 SPLIT = $self->{SPLIT}
395 Defines the clean target.
400 # --- Cleanup and Distribution Sections ---
402 my($self, %attribs) = @_;
405 # Delete temporary files but do not touch installed files. We don\'t delete
406 # the Makefile here so a later make realclean still has a makefile to use.
410 # clean subdirectories first
411 for $dir (@{$self->{DIR}}) {
412 push @m, "\t-cd $dir && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) clean\n";
415 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
416 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
417 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
418 perlmain.c mon.out core so_locations pm_to_blib
419 *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe
420 $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
423 push @m, "\t-$self->{RM_RF} @otherfiles\n";
424 # See realclean and ext/utils/make_ext for usage of Makefile.old
426 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old \$(DEV_NULL)\n");
428 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
432 =item const_cccmd (o)
434 Returns the full compiler call for C programs and stores the
435 definition in CONST_CCCMD.
440 my($self,$libperl)=@_;
441 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
442 return '' unless $self->needs_linking();
443 return $self->{CONST_CCCMD} =
444 q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
445 $(PERLTYPE) $(LARGE) $(SPLIT) $(DEFINE_VERSION) \\
446 $(XS_DEFINE_VERSION)};
449 =item const_config (o)
451 Defines a couple of constants in the Makefile that are imported from
457 # --- Constants Sections ---
461 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
462 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
464 foreach $m (@{$self->{CONFIG}}){
465 # SITE*EXP macros are defined in &constants; avoid duplicates here
466 next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
467 push @m, "\U$m\E = ".$self->{uc $m}."\n";
473 =item const_loadlibs (o)
475 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
476 L<ExtUtils::Liblist> for details.
482 return "" unless $self->needs_linking;
485 # $self->{NAME} might depend on some other libraries:
486 # See ExtUtils::Liblist for details
491 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
493 next unless defined $self->{$tmp};
494 push @m, "$tmp = $self->{$tmp}\n";
501 Initializes lots of constants and .SUFFIXES and .PHONY
511 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
512 VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
513 INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
514 INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
515 INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
516 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
517 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
518 PERL_INC PERL FULLPERL
521 next unless defined $self->{$tmp};
522 push @m, "$tmp = $self->{$tmp}\n";
526 VERSION_MACRO = VERSION
527 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
528 XS_VERSION_MACRO = XS_VERSION
529 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
533 MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
534 MM_VERSION = $ExtUtils::MakeMaker::VERSION
538 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
539 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
540 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD) !!! Deprecated from MM 5.32 !!!
541 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
542 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
546 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
549 next unless defined $self->{$tmp};
550 push @m, "$tmp = $self->{$tmp}\n";
554 # Handy lists of source code files:
555 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
556 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
557 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
558 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
559 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
560 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
564 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
566 next unless defined $self->{$tmp};
567 push @m, "$tmp = $self->{$tmp}\n";
574 my $method = lc($tmp);
575 # warn "self[$self] method[$method]";
576 push @m, "$tmp = ", $self->$method(), "\n";
580 .NO_CONFIG_REC: Makefile
581 } if $ENV{CLEARCASE_ROOT};
583 # why not q{} ? -- emacs
585 # work around a famous dec-osf make(1) feature(?):
588 .SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
590 # Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
591 # some make implementations will delete the Makefile when we rebuild it. Because
592 # we call false(1) when we rebuild it. So make(1) is not completely wrong when it
593 # does so. Our milage may vary.
594 # .PRECIOUS: Makefile # seems to be not necessary anymore
596 .PHONY: all config static dynamic test linkext manifest
598 # Where is the Config information that we are using/depend on
599 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
602 my @parentdir = split(/::/, $self->{PARENT_NAME});
604 # Where to put things:
605 INST_LIBDIR = }. $self->catdir('$(INST_LIB)',@parentdir) .q{
606 INST_ARCHLIBDIR = }. $self->catdir('$(INST_ARCHLIB)',@parentdir) .q{
608 INST_AUTODIR = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)') .q{
609 INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)') .q{
612 if ($self->has_link_code()) {
614 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
615 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
616 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
626 $tmp = $self->export_list;
630 $tmp = $self->perl_archive;
636 #INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
638 #PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
642 TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
644 PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
652 Same as macro for the depend attribute.
657 my($self,%attribs) = @_;
659 while (($key,$val) = each %attribs){
660 last unless defined $key;
661 push @m, "$key: $val\n";
668 Takes an array of directories that need to exist and returns a
669 Makefile entry for a .exists file in these directories. Returns
670 nothing, if the entry has already been processed. We're helpless
671 though, if the same directory comes as $(FOO) _and_ as "bar". Both of
672 them get an entry, that's why we use "::".
677 # --- Make-Directories section (internal method) ---
678 # dir_target(@array) returns a Makefile entry for the file .exists in each
679 # named directory. Returns nothing, if the entry has already been processed.
680 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
681 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
682 # prerequisite, because there has to be one, something that doesn't change
685 my($self,@dirs) = @_;
686 my(@m,$dir,$targdir);
687 foreach $dir (@dirs) {
688 my($src) = $self->catfile($self->{PERL_INC},'perl.h');
689 my($targ) = $self->catfile($dir,'.exists');
690 # catfile may have adapted syntax of $dir to target OS, so...
691 if ($Is_VMS) { # Just remove file name; dirspec is often in macro
692 ($targdir = $targ) =~ s:/?\.exists$::;
694 else { # while elsewhere we expect to see the dir separator in $targ
695 $targdir = dirname($targ);
697 next if $self->{DIR_TARGET}{$self}{$targdir}++;
700 $self->{NOECHO}\$(MKPATH) $targdir
701 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
704 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $targdir
712 Defines a lot of macros for distribution support.
717 my($self, %attribs) = @_;
720 # VERSION should be sanitised before use as a file name
721 my($version) = $attribs{VERSION} || '$(VERSION)';
722 my($name) = $attribs{NAME} || '$(DISTNAME)';
723 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
724 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
725 my($zip) = $attribs{ZIP} || 'zip'; # eg pkzip Yuck!
726 my($zipflags) = $attribs{ZIPFLAGS} || '-r';
727 my($compress) = $attribs{COMPRESS} || 'compress'; # eg gzip
728 my($suffix) = $attribs{SUFFIX} || '.Z'; # eg .gz
729 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
730 my($preop) = $attribs{PREOP} || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
731 my($postop) = $attribs{POSTOP} || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
733 my($to_unix) = $attribs{TO_UNIX} || ($Is_OS2
735 . '$(TEST_F) tmp.zip && $(RM) tmp.zip;'
736 . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
737 : "$self->{NOECHO}\$(NOOP)");
739 my($ci) = $attribs{CI} || 'ci -u';
740 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
741 my($dist_cp) = $attribs{DIST_CP} || 'best';
742 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
745 DISTVNAME = ${name}-$version
757 RCS_LABEL = $rcs_label
759 DIST_DEFAULT = $dist_default
764 =item dist_basics (o)
766 Defines the targets distclean, distcheck, skipcheck, manifest.
774 distclean :: realclean distcheck
779 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \\
785 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \\
791 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \\
799 Defines a check in target for RCS.
808 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \\
809 -e "@all = keys %{ maniread() };" \\
810 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
811 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
818 Defeines the targets dist, tardist, zipdist, uutardist, shdist
826 dist : $(DIST_DEFAULT)
827 }.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
828 -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
830 tardist : $(DISTVNAME).tar$(SUFFIX)
832 zipdist : $(DISTVNAME).zip
834 $(DISTVNAME).tar$(SUFFIX) : distdir
837 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
838 $(RM_RF) $(DISTVNAME)
839 $(COMPRESS) $(DISTVNAME).tar
842 $(DISTVNAME).zip : distdir
844 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
845 $(RM_RF) $(DISTVNAME)
848 uutardist : $(DISTVNAME).tar$(SUFFIX)
849 uuencode $(DISTVNAME).tar$(SUFFIX) \\
850 $(DISTVNAME).tar$(SUFFIX) > \\
851 $(DISTVNAME).tar$(SUFFIX)_uu
855 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
856 $(RM_RF) $(DISTVNAME)
864 Defines the scratch directory target that will hold the distribution
865 before tar-ing (or shar-ing).
874 $(RM_RF) $(DISTVNAME)
875 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
876 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
883 Defines a target that produces the distribution in the
884 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
894 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
895 cd $(DISTVNAME) && $(MAKE)
896 cd $(DISTVNAME) && $(MAKE) test
903 Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
909 my($self,%attribs) = @_;
911 return '' unless ($^O eq 'aix' && $self->needs_linking() );
913 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
914 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
918 dynamic :: $self->{BASEEXT}.exp
920 ") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
923 static :: $self->{BASEEXT}.exp
925 ") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
928 $self->{BASEEXT}.exp: Makefile.PL
929 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
930 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
931 neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
939 Defines the dynamic target.
944 # --- Dynamic Loading Sections ---
948 ## $(INST_PM) has been moved to the all: target.
949 ## It remains here for awhile to allow for old usage: "make dynamic"
950 #dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
951 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
952 '.$self->{NOECHO}.'$(NOOP)
958 Defines targets for bootstrap files.
963 my($self, %attribs) = @_;
966 ' unless $self->has_link_code();
969 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
971 # As Mkbootstrap might not write a file (if none is required)
972 # we use touch to prevent make continually trying to remake it.
973 # The DynaLoader only reads a non-empty file.
974 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
975 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
976 '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
977 -MExtUtils::Mkbootstrap \
978 -e "Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
979 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
980 $(CHMOD) $(PERM_RW) $@
982 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
983 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
984 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
985 $(CHMOD) $(PERM_RW) $@
989 =item dynamic_lib (o)
991 Defines how to produce the *.so (or equivalent) files.
996 my($self, %attribs) = @_;
997 return '' unless $self->needs_linking(); #might be because of a subdir
999 return '' unless $self->has_link_code;
1001 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1002 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1003 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1004 my($ldfrom) = '$(LDFROM)';
1005 $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
1008 # This section creates the dynamically loadable $(INST_DYNAMIC)
1009 # from $(OBJECT) and possibly $(MYEXTLIB).
1010 ARMAYBE = '.$armaybe.'
1011 OTHERLDFLAGS = '.$otherldflags.'
1012 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1014 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
1016 if ($armaybe ne ':'){
1017 $ldfrom = 'tmp$(LIB_EXT)';
1018 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1019 push(@m,' $(RANLIB) '."$ldfrom\n");
1021 $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
1023 # Brain dead solaris linker does not use LD_RUN_PATH?
1024 # This fixes dynamic extensions which need shared libs
1026 $ldrun = join ' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}
1027 if ($^O eq 'solaris');
1029 # The IRIX linker also doesn't use LD_RUN_PATH
1030 $ldrun = qq{-rpath "$self->{LD_RUN_PATH}"}
1031 if ($^O eq 'irix' && $self->{LD_RUN_PATH});
1033 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ '.$ldrun.' $(LDDLFLAGS) '.$ldfrom.
1034 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)');
1036 $(CHMOD) $(PERM_RWX) $@
1039 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1045 Deprecated method. Use libscan instead.
1050 my($self,$path) = @_;
1056 Called by init_others, and calls ext ExtUtils::Liblist. See
1057 L<ExtUtils::Liblist> for details.
1062 my($self,$libs) = @_;
1063 require ExtUtils::Liblist;
1064 $self->ext($libs, $Verbose);
1067 =item file_name_is_absolute
1069 Takes as argument a path and returns true, if it is an absolute path.
1073 sub file_name_is_absolute {
1074 my($self,$file) = @_;
1076 $file =~ m{^([a-z]:)?[\\/]}i ;
1085 Finds the executables PERL and FULLPERL
1090 my($self, $ver, $names, $dirs, $trace) = @_;
1093 print "Looking for perl $ver by these names:
1099 foreach $dir (@$dirs){
1100 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1101 foreach $name (@$names){
1103 if ($self->file_name_is_absolute($name)) { # /foo/bar
1105 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
1106 $abs = $self->catfile($dir, $name);
1108 $abs = $self->canonpath($self->catfile($self->curdir, $name));
1110 print "Checking $abs\n" if ($trace >= 2);
1111 next unless $self->maybe_command($abs);
1112 print "Executing $abs\n" if ($trace >= 2);
1113 $val = `$abs -e 'require $ver; print "VER_OK\n" ' 2>&1`;
1114 if ($val =~ /VER_OK/) {
1115 print "Using PERL=$abs\n" if $trace;
1117 } elsif ($trace >= 2) {
1118 print "Result: `$val'\n";
1122 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1123 0; # false and not empty
1128 =head2 Methods to actually produce chunks of text for the Makefile
1130 The methods here are called for each MakeMaker object in the order
1131 specified by @ExtUtils::MakeMaker::MM_Sections.
1137 Inserts the sharpbang or equivalent magic number to a script
1141 sub fixin { # stolen from the pink Camel book, more or less
1142 my($self,@files) = @_;
1143 my($does_shbang) = $Config::Config{'sharpbang'} =~ /^\s*\#\!/;
1144 my($file,$interpreter);
1145 for $file (@files) {
1148 open(FIXIN, $file) or Carp::croak "Can't process '$file': $!";
1150 chomp(my $line = <FIXIN>);
1151 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
1152 # Now figure out the interpreter name.
1153 my($cmd,$arg) = split ' ', $line, 2;
1156 # Now look (in reverse) for interpreter in absolute PATH (unless perl).
1157 if ($cmd eq "perl") {
1158 if ($Config{startperl} =~ m,^\#!.*/perl,) {
1159 $interpreter = $Config{startperl};
1160 $interpreter =~ s,^\#!,,;
1162 $interpreter = $Config{perlpath};
1165 my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1168 foreach $dir (@absdirs) {
1169 if ($self->maybe_command($cmd)) {
1170 warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1171 $interpreter = $self->catfile($dir,$cmd);
1175 # Figure out how to invoke interpreter on this machine.
1179 print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1180 # this is probably value-free on DOSISH platforms
1182 $shb .= "$Config{'sharpbang'}$interpreter";
1183 $shb .= ' ' . $arg if defined $arg;
1187 eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1188 if 0; # not running under some shell
1189 } unless $Is_Win32; # this won't work on win32, so don't
1191 warn "Can't find $cmd in PATH, $file unchanged"
1196 unless ( open(FIXOUT,">$file.new") ) {
1197 warn "Can't create new $file: $!\n";
1200 my($dev,$ino,$mode) = stat FIXIN;
1201 # If they override perm_rwx, we won't notice it during fixin,
1202 # because fixin is run through a new instance of MakeMaker.
1203 # That is why we must run another CHMOD later.
1204 $mode = oct($self->perm_rwx) unless $dev;
1207 # Print out the new #! line (or equivalent).
1210 print FIXOUT $shb, <FIXIN>;
1213 # can't rename open files on some DOSISH platforms
1214 unless ( rename($file, "$file.bak") ) {
1215 warn "Can't rename $file to $file.bak: $!";
1218 unless ( rename("$file.new", $file) ) {
1219 warn "Can't rename $file.new to $file: $!";
1220 unless ( rename("$file.bak", $file) ) {
1221 warn "Can't rename $file.bak back to $file either: $!";
1222 warn "Leaving $file renamed as $file.bak\n";
1228 chmod oct($self->perm_rwx), $file or
1229 die "Can't reset permissions for $file: $!\n";
1230 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1242 '# Phony target to force checking subdirectories.
1244 '.$self->{NOECHO}.'$(NOOP)
1250 Guess the name of this package by examining the working directory's
1251 name. MakeMaker calls this only if the developer has not supplied a
1261 my $name = basename(cwd());
1262 $name =~ s|[\-_][\d\.\-]+$||; # this is new with MM 5.00, we
1263 # strip minus or underline
1264 # followed by a float or some such
1265 print "Warning: Guessing NAME [$name] from current directory name.\n";
1271 Returns true if C, XS, MYEXTLIB or similar objects exist within this
1272 object that need a compiler. Does not descend into subdirectories as
1273 needs_linking() does.
1279 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1280 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
1281 $self->{HAS_LINK_CODE} = 1;
1284 return $self->{HAS_LINK_CODE} = 0;
1289 Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
1293 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1295 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1296 local(%pm); #the sub in find() has to see this hash
1297 @ignore{qw(Makefile.PL test.pl)} = (1,1);
1298 $ignore{'makefile.pl'} = 1 if $Is_VMS;
1299 foreach $name ($self->lsdir($self->curdir)){
1300 next if $name =~ /\#/;
1301 next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
1302 next unless $self->libscan($name);
1304 next if -l $name; # We do not support symlinks at all
1305 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1306 } elsif ($name =~ /\.xs$/){
1307 my($c); ($c = $name) =~ s/\.xs$/.c/;
1310 } elsif ($name =~ /\.c(pp|xx|c)?$/i){ # .c .C .cpp .cxx .cc
1312 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1313 } elsif ($name =~ /\.h$/i){
1315 } elsif ($name =~ /\.PL$/) {
1316 ($pl_files{$name} = $name) =~ s/\.PL$// ;
1317 } elsif ($Is_VMS && $name =~ /\.pl$/) { # case-insensitive filesystem
1318 local($/); open(PL,$name); my $txt = <PL>; close PL;
1319 if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1320 ($pl_files{$name} = $name) =~ s/\.pl$// ;
1322 else { $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name); }
1323 } elsif ($name =~ /\.(p[ml]|pod)$/){
1324 $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
1328 # Some larger extensions often wish to install a number of *.pm/pl
1329 # files into the library in various locations.
1331 # The attribute PMLIBDIRS holds an array reference which lists
1332 # subdirectories which we should search for library files to
1333 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1334 # recursively search through the named directories (skipping any
1335 # which don't exist or contain Makefile.PL files).
1337 # For each *.pm or *.pl file found $self->libscan() is called with
1338 # the default installation path in $_[1]. The return value of
1339 # libscan defines the actual installation location. The default
1340 # libscan function simply returns the path. The file is skipped
1341 # if libscan returns false.
1343 # The default installation location passed to libscan in $_[1] is:
1345 # ./*.pm => $(INST_LIBDIR)/*.pm
1346 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1347 # ./lib/... => $(INST_LIB)/...
1349 # In this way the 'lib' directory is seen as the root of the actual
1350 # perl library whereas the others are relative to INST_LIBDIR
1351 # (which includes PARENT_NAME). This is a subtle distinction but one
1352 # that's important for nested modules.
1354 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1355 unless $self->{PMLIBDIRS};
1357 #only existing directories that aren't in $dir are allowed
1359 # Avoid $_ wherever possible:
1360 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1361 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1363 @{$self->{PMLIBDIRS}} = ();
1364 foreach $pmlibdir (@pmlibdirs) {
1365 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1368 if (@{$self->{PMLIBDIRS}}){
1369 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1372 File::Find::find(sub {
1374 if ($_ eq "CVS" || $_ eq "RCS"){
1375 $File::Find::prune = 1;
1380 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1381 my($striplibpath,$striplibname);
1382 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i);
1383 ($striplibname,$striplibpath) = fileparse($striplibpath);
1384 my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
1385 local($_) = $inst; # for backwards compatibility
1386 $inst = $self->libscan($inst);
1387 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1388 return unless $inst;
1390 }, @{$self->{PMLIBDIRS}});
1393 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1394 $self->{XS} = \%xs unless $self->{XS};
1395 $self->{PM} = \%pm unless $self->{PM};
1396 $self->{C} = [sort keys %c] unless $self->{C};
1397 my(@o_files) = @{$self->{C}};
1398 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
1399 $self->{H} = [sort keys %h] unless $self->{H};
1400 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1402 # Set up names of manual pages to generate from pods
1403 if ($self->{MAN1PODS}) {
1404 } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1405 $self->{MAN1PODS} = {};
1407 my %manifypods = ();
1408 if ( exists $self->{EXE_FILES} ) {
1409 foreach $name (@{$self->{EXE_FILES}}) {
1410 # use FileHandle ();
1411 # my $fh = new FileHandle;
1414 # if ($fh->open("<$name")) {
1415 if (open(FH,"<$name")) {
1418 if (/^=head1\s+\w+/) {
1426 # If it doesn't exist yet, we assume, it has pods in it
1430 $manifypods{$name} =
1431 $self->catfile('$(INST_MAN1DIR)',
1432 basename($name).'.$(MAN1EXT)');
1436 $self->{MAN1PODS} = \%manifypods;
1438 if ($self->{MAN3PODS}) {
1439 } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1440 $self->{MAN3PODS} = {};
1442 my %manifypods = (); # we collect the keys first, i.e. the files
1443 # we have to convert to pod
1444 foreach $name (keys %{$self->{PM}}) {
1445 if ($name =~ /\.pod$/ ) {
1446 $manifypods{$name} = $self->{PM}{$name};
1447 } elsif ($name =~ /\.p[ml]$/ ) {
1448 # use FileHandle ();
1449 # my $fh = new FileHandle;
1452 # $fh->open("<$name");
1453 if (open(FH,"<$name")) {
1456 if (/^=head1\s+\w+/) {
1467 $manifypods{$name} = $self->{PM}{$name};
1472 # Remove "Configure.pm" and similar, if it's not the only pod listed
1473 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1474 foreach $name (keys %manifypods) {
1475 if ($name =~ /(config|setup).*\.pm/i) {
1476 delete $manifypods{$name};
1479 my($manpagename) = $name;
1480 unless ($manpagename =~ s!^\W*lib\W+!!) { # everything below lib is ok
1481 $manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1483 $manpagename =~ s/\.p(od|m|l)$//;
1484 $manpagename = $self->replace_manpage_separator($manpagename);
1485 $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
1487 $self->{MAN3PODS} = \%manifypods;
1493 Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
1494 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
1495 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, EXE_EXT, MAP_TARGET,
1496 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
1503 # --- Initialize Module Name and Paths
1505 # NAME = Foo::Bar::Oracle
1506 # FULLEXT = Foo/Bar/Oracle
1508 # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
1509 # PARENT_NAME = Foo::Bar
1511 ### ($self->{FULLEXT} =
1512 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1513 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1516 # Copied from DynaLoader:
1518 my(@modparts) = split(/::/,$self->{NAME});
1519 my($modfname) = $modparts[-1];
1521 # Some systems have restrictions on files names for DLL's etc.
1522 # mod2fname returns appropriate file base name (typically truncated)
1523 # It may also edit @modparts if required.
1524 if (defined &DynaLoader::mod2fname) {
1525 $modfname = &DynaLoader::mod2fname(\@modparts);
1528 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)$! ;
1530 if (defined &DynaLoader::mod2fname) {
1531 # As of 5.001m, dl_os2 appends '_'
1532 $self->{DLBASE} = $modfname;
1534 $self->{DLBASE} = '$(BASEEXT)';
1538 ### ROOTEXT deprecated from MM 5.32
1539 ### ($self->{ROOTEXT} =
1540 ### $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
1541 ### $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
1544 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
1546 # *Real* information: where did we get these two from? ...
1547 my $inc_config_dir = dirname($INC{'Config.pm'});
1548 my $inc_carp_dir = dirname($INC{'Carp.pm'});
1550 unless ($self->{PERL_SRC}){
1552 foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir())){
1554 -f $self->catfile($dir,"config.sh")
1556 -f $self->catfile($dir,"perl.h")
1558 -f $self->catfile($dir,"lib","Exporter.pm")
1560 $self->{PERL_SRC}=$dir ;
1565 if ($self->{PERL_SRC}){
1566 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
1567 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1568 $self->{PERL_INC} = ($Is_Win32) ? $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1570 # catch a situation that has occurred a few times in the past:
1572 -s $self->catfile($self->{PERL_SRC},'cflags')
1576 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1583 You cannot build extensions below the perl source tree after executing
1584 a 'make clean' in the perl source tree.
1586 To rebuild extensions distributed with the perl source you should
1587 simply Configure (to include those extensions) and then build perl as
1588 normal. After installing perl the source tree can be deleted. It is
1589 not needed for building extensions by running 'perl Makefile.PL'
1590 usually without extra arguments.
1592 It is recommended that you unpack and build additional extensions away
1593 from the perl source tree.
1597 # we should also consider $ENV{PERL5LIB} here
1598 $self->{PERL_LIB} ||= $Config::Config{privlibexp};
1599 $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
1600 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1602 unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))){
1604 Error: Unable to locate installed Perl libraries or Perl source code.
1606 It is recommended that you install perl in a standard location before
1607 building extensions. Some precompiled versions of perl do not contain
1608 these header files, so you cannot build extensions. In such a case,
1609 please build and install your perl from a fresh perl distribution. It
1610 usually solves this kind of problem.
1612 \(You get this message, because MakeMaker could not find "$perl_h"\)
1615 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
1616 # if $Verbose && $self->needs_linking();
1620 # We get SITELIBEXP and SITEARCHEXP directly via
1621 # Get_from_Config. When we are running standard modules, these
1622 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1623 # set it to "site". I prefer that INSTALLDIRS be set from outside
1625 $self->{INSTALLDIRS} ||= "site";
1627 # INST_LIB typically pre-set if building an extension after
1628 # perl has been built and installed. Setting INST_LIB allows
1629 # you to build directly into, say $Config::Config{privlibexp}.
1630 unless ($self->{INST_LIB}){
1633 ##### XXXXX We have to change this nonsense
1635 if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
1636 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1638 $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
1641 $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
1642 $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
1644 # We need to set up INST_LIBDIR before init_libscan() for VMS
1645 my @parentdir = split(/::/, $self->{PARENT_NAME});
1646 $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)',@parentdir);
1647 $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)',@parentdir);
1648 $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)','auto','$(FULLEXT)');
1649 $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)');
1651 # INST_EXE is deprecated, should go away March '97
1652 $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
1653 $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
1655 # The user who requests an installation directory explicitly
1656 # should not have to tell us a architecture installation directory
1657 # as well. We look if a directory exists that is named after the
1658 # architecture. If not we take it as a sign that it should be the
1659 # same as the requested installation directory. Otherwise we take
1661 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
1663 for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
1664 my $lib = "install$libpair->{l}";
1666 my $Arch = uc "install$libpair->{a}";
1667 if( $self->{$Lib} && ! $self->{$Arch} ){
1668 my($ilib) = $Config{$lib};
1669 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
1671 $self->prefixify($Arch,$ilib,$self->{$Lib});
1673 unless (-d $self->{$Arch}) {
1674 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
1675 $self->{$Arch} = $self->{$Lib};
1677 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1681 # we have to look at the relation between $Config{prefix} and the
1682 # requested values. We're going to set the $Config{prefix} part of
1683 # all the installation path variables to literally $(PREFIX), so
1684 # the user can still say make PREFIX=foo
1685 my($configure_prefix) = $Config{'prefix'};
1686 $configure_prefix = VMS::Filespec::unixify($configure_prefix) if $Is_VMS;
1687 $self->{PREFIX} ||= $configure_prefix;
1690 my($install_variable,$search_prefix,$replace_prefix);
1692 # The rule, taken from Configure, is that if prefix contains perl,
1694 # perlprefix/lib/ INSTALLPRIVLIB
1695 # perlprefix/lib/pod/
1696 # perlprefix/lib/site_perl/ INSTALLSITELIB
1697 # perlprefix/bin/ INSTALLBIN
1698 # perlprefix/man/ INSTALLMAN1DIR
1700 # prefix/lib/perl5/ INSTALLPRIVLIB
1701 # prefix/lib/perl5/pod/
1702 # prefix/lib/perl5/site_perl/ INSTALLSITELIB
1703 # prefix/bin/ INSTALLBIN
1704 # prefix/lib/perl5/man/ INSTALLMAN1DIR
1706 $replace_prefix = qq[\$\(PREFIX\)];
1707 for $install_variable (qw/
1711 $self->prefixify($install_variable,$configure_prefix,$replace_prefix);
1713 $search_prefix = $configure_prefix =~ /perl/ ?
1714 $self->catdir($configure_prefix,"lib") :
1715 $self->catdir($configure_prefix,"lib","perl5");
1717 $self->{INSTALLPRIVLIB} = $self->{INSTALLSITELIB} = $self->{LIB};
1718 $self->{INSTALLARCHLIB} = $self->{INSTALLSITEARCH} =
1719 $self->catdir($self->{LIB},$Config{'archname'});
1721 $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1722 $self->catdir(qq[\$\(PREFIX\)],"lib") :
1723 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5");
1724 for $install_variable (qw/
1730 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1733 $search_prefix = $configure_prefix =~ /perl/ ?
1734 $self->catdir($configure_prefix,"man") :
1735 $self->catdir($configure_prefix,"lib","perl5","man");
1736 $replace_prefix = $self->{PREFIX} =~ /perl/ ?
1737 $self->catdir(qq[\$\(PREFIX\)],"man") :
1738 $self->catdir(qq[\$\(PREFIX\)],"lib","perl5","man");
1739 for $install_variable (qw/
1743 $self->prefixify($install_variable,$search_prefix,$replace_prefix);
1746 # Now we head at the manpages. Maybe they DO NOT want manpages
1748 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
1749 unless defined $self->{INSTALLMAN1DIR};
1750 unless (defined $self->{INST_MAN1DIR}){
1751 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
1752 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
1754 $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
1757 $self->{MAN1EXT} ||= $Config::Config{man1ext};
1759 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
1760 unless defined $self->{INSTALLMAN3DIR};
1761 unless (defined $self->{INST_MAN3DIR}){
1762 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
1763 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
1765 $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
1768 $self->{MAN3EXT} ||= $Config::Config{man3ext};
1771 # Get some stuff out of %Config if we haven't yet done so
1772 print STDOUT "CONFIG must be an array ref\n"
1773 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1774 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1775 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1776 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1778 foreach $m (@{$self->{CONFIG}}){
1779 next if $once_only{$m};
1780 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1781 unless exists $Config::Config{$m};
1782 $self->{uc $m} ||= $Config::Config{$m};
1786 # This is too dangerous:
1787 # if ($^O eq "next") {
1788 # $self->{AR} = "libtool";
1789 # $self->{AR_STATIC_ARGS} = "-o";
1791 # But I leave it as a placeholder
1793 $self->{AR_STATIC_ARGS} ||= "cr";
1795 # These should never be needed
1796 $self->{LD} ||= 'ld';
1797 $self->{OBJ_EXT} ||= '.o';
1798 $self->{LIB_EXT} ||= '.a';
1800 $self->{MAP_TARGET} ||= "perl";
1802 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1804 # make a simple check if we find Exporter
1805 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1806 (Exporter.pm not found)"
1807 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1808 $self->{NAME} eq "ExtUtils::MakeMaker";
1810 # Determine VERSION and VERSION_FROM
1811 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1812 if ($self->{VERSION_FROM}){
1813 $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
1814 Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
1818 if ($self->{VERSION}) {
1819 $self->{VERSION} =~ s/^\s+//;
1820 $self->{VERSION} =~ s/\s+$//;
1823 $self->{VERSION} ||= "0.10";
1824 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1827 # Graham Barr and Paul Marquess had some ideas how to ensure
1828 # version compatibility between the *.pm file and the
1829 # corresponding *.xs file. The bottomline was, that we need an
1830 # XS_VERSION macro that defaults to VERSION:
1831 $self->{XS_VERSION} ||= $self->{VERSION};
1833 # --- Initialize Perl Binary Locations
1835 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1836 # will be working versions of perl 5. miniperl has priority over perl
1837 # for PERL to ensure that $(PERL) is usable while building ./ext/*
1838 my ($component,@defpath);
1839 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1840 push @defpath, $component if defined $component;
1843 $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1844 \@defpath, $Verbose );
1845 # don't check if perl is executable, maybe they have decided to
1846 # supply switches with perl
1848 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1849 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1850 unless ($self->{FULLPERL});
1855 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1856 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1857 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1861 sub init_others { # --- Initialize Other Attributes
1864 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1865 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1866 # undefined. In any case we turn it into an anon array:
1868 # May check $Config{libs} too, thus not empty.
1869 $self->{LIBS}=[''] unless $self->{LIBS};
1871 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1872 $self->{LD_RUN_PATH} = "";
1874 foreach $libs ( @{$self->{LIBS}} ){
1875 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1876 my(@libs) = $self->extliblist($libs);
1877 if ($libs[0] or $libs[1] or $libs[2]){
1878 # LD_RUN_PATH now computed by ExtUtils::Liblist
1879 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1884 if ( $self->{OBJECT} ) {
1885 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1887 # init_dirscan should have found out, if we have C files
1888 $self->{OBJECT} = "";
1889 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1891 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1892 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1893 $self->{PERLMAINCC} ||= '$(CC)';
1894 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1896 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1897 # the 'dynamic' section of MM. We don't have this problem with
1898 # 'static', since we either must use it (%Config says we can't
1899 # use dynamic loading) or the caller asked for it explicitly.
1900 if (!$self->{LINKTYPE}) {
1901 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1903 : ($Config::Config{usedl} ? 'dynamic' : 'static');
1906 # These get overridden for VMS and maybe some other systems
1907 $self->{NOOP} ||= '$(SHELL) -c true';
1908 $self->{FIRST_MAKEFILE} ||= "Makefile";
1909 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1910 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1911 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1912 $self->{RM_F} ||= "rm -f";
1913 $self->{RM_RF} ||= "rm -rf";
1914 $self->{TOUCH} ||= "touch";
1915 $self->{TEST_F} ||= "test -f";
1916 $self->{CP} ||= "cp";
1917 $self->{MV} ||= "mv";
1918 $self->{CHMOD} ||= "chmod";
1919 $self->{UMASK_NULL} ||= "umask 0";
1920 $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1925 Defines the install target.
1930 my($self, %attribs) = @_;
1934 install :: all pure_install doc_install
1936 install_perl :: all pure_perl_install doc_perl_install
1938 install_site :: all pure_site_install doc_site_install
1940 install_ :: install_site
1941 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1943 pure_install :: pure_$(INSTALLDIRS)_install
1945 doc_install :: doc_$(INSTALLDIRS)_install
1946 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
1948 pure__install : pure_site_install
1949 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1951 doc__install : doc_site_install
1952 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
1954 pure_perl_install ::
1955 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1956 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1957 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
1958 $(INST_LIB) $(INSTALLPRIVLIB) \
1959 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
1960 $(INST_BIN) $(INSTALLBIN) \
1961 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1962 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1963 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1964 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1965 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
1968 pure_site_install ::
1969 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
1970 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
1971 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
1972 $(INST_LIB) $(INSTALLSITELIB) \
1973 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
1974 $(INST_BIN) $(INSTALLBIN) \
1975 $(INST_SCRIPT) $(INSTALLSCRIPT) \
1976 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
1977 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
1978 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
1979 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
1982 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
1983 "Module" "$(NAME)" \
1984 "installed into" "$(INSTALLPRIVLIB)" \
1985 LINKTYPE "$(LINKTYPE)" \
1986 VERSION "$(VERSION)" \
1987 EXE_FILES "$(EXE_FILES)" \
1988 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
1991 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
1992 "Module" "$(NAME)" \
1993 "installed into" "$(INSTALLSITELIB)" \
1994 LINKTYPE "$(LINKTYPE)" \
1995 VERSION "$(VERSION)" \
1996 EXE_FILES "$(EXE_FILES)" \
1997 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2002 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2004 uninstall_from_perldirs ::
2006 q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2008 uninstall_from_sitedirs ::
2010 q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2016 =item installbin (o)
2018 Defines targets to install EXE_FILES.
2024 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2025 return "" unless @{$self->{EXE_FILES}};
2026 my(@m, $from, $to, %fromto, @to);
2027 push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2028 for $from (@{$self->{EXE_FILES}}) {
2029 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2030 local($_) = $path; # for backwards compatibility
2031 $to = $self->libscan($path);
2032 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2035 @to = values %fromto;
2037 EXE_FILES = @{$self->{EXE_FILES}}
2040 ? q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2041 -e "system qq[pl2bat.bat ].shift"
2042 } : q{FIXIN = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::MakeMaker \
2043 -e "MY->fixin(shift)"
2046 $self->{NOECHO}\$(NOOP)
2052 while (($from,$to) = each %fromto) {
2053 last unless defined $from;
2054 my $todir = dirname($to);
2056 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2057 $self->{NOECHO}$self->{RM_F} $to
2058 $self->{CP} $from $to
2060 -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2068 Takes a path to a file that is found by init_dirscan and returns false
2069 if we don't want to include this file in the library. Mainly used to
2070 exclude RCS, CVS, and SCCS directories from installation.
2077 my($self,$path) = @_;
2078 return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2084 Defines the linkext target which in turn defines the LINKTYPE.
2089 my($self, %attribs) = @_;
2090 # LINKTYPE => static or dynamic or ''
2091 my($linktype) = defined $attribs{LINKTYPE} ?
2092 $attribs{LINKTYPE} : '$(LINKTYPE)';
2094 linkext :: $linktype
2095 $self->{NOECHO}\$(NOOP)
2101 Takes as arguments a directory name and a regular expression. Returns
2102 all entries in the directory that match the regular expression.
2108 my($dir, $regex) = @_;
2110 my $dh = new DirHandle;
2111 $dh->open($dir || ".") or return ();
2114 @ls = grep(/$regex/, @ls) if $regex;
2120 Simple subroutine to insert the macros defined by the macro attribute
2126 my($self,%attribs) = @_;
2128 while (($key,$val) = each %attribs){
2129 last unless defined $key;
2130 push @m, "$key = $val\n";
2137 Called by staticmake. Defines how to write the Makefile to produce a
2140 By default the Makefile produced includes all the static extensions in
2141 the perl library. (Purified versions of library files, e.g.,
2142 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2147 my($self, %attribs) = @_;
2148 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2149 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2152 # --- MakeMaker makeaperl section ---
2153 MAP_TARGET = $target
2154 FULLPERL = $self->{FULLPERL}
2156 return join '', @m if $self->{PARENT};
2158 my($dir) = join ":", @{$self->{DIR}};
2160 unless ($self->{MAKEAPERL}) {
2162 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2163 $(MAKE) -f $(MAKE_APERL_FILE) $@
2165 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2166 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2167 }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2168 Makefile.PL DIR=}, $dir, q{ \
2169 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2170 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2176 push @m, " \\\n\t\t$_";
2178 # push @m, map( " \\\n\t\t$_", @ARGV );
2186 my($cccmd, $linkcmd, $lperl);
2189 $cccmd = $self->const_cccmd($libperl);
2190 $cccmd =~ s/^CCCMD\s*=\s*//;
2191 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2192 $cccmd .= " $Config::Config{cccdlflags}"
2193 if ($Config::Config{useshrplib} eq 'true');
2194 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2196 # The front matter of the linkcommand...
2197 $linkcmd = join ' ', "\$(CC)",
2198 grep($_, @Config{qw(large split ldflags ccdlflags)});
2199 $linkcmd =~ s/\s+/ /g;
2200 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2202 # Which *.a files could we make use of...
2205 File::Find::find(sub {
2206 return unless m/\Q$self->{LIB_EXT}\E$/;
2207 return if m/^libperl/;
2208 # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2209 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2211 if( exists $self->{INCLUDE_EXT} ){
2216 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2220 # Throw away anything not explicitly marked for inclusion.
2221 # DynaLoader is implied.
2222 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2228 return unless $found;
2230 elsif( exists $self->{EXCLUDE_EXT} ){
2234 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2238 # Throw away anything explicitly marked for exclusion
2239 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2240 return if( $xx eq $excl );
2244 # don't include the installed version of this extension. I
2245 # leave this line here, although it is not necessary anymore:
2246 # I patched minimod.PL instead, so that Miniperl.pm won't
2247 # enclude duplicates
2249 # Once the patch to minimod.PL is in the distribution, I can
2251 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2253 $static{cwd() . "/" . $_}++;
2254 }, grep( -d $_, @{$searchdirs || []}) );
2256 # We trust that what has been handed in as argument, will be buildable
2257 $static = [] unless $static;
2258 @static{@{$static}} = (1) x @{$static};
2260 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2261 for (sort keys %static) {
2262 next unless /\Q$self->{LIB_EXT}\E$/;
2263 $_ = dirname($_) . "/extralibs.ld";
2267 grep(s/^/-I/, @{$perlinc || []});
2269 $target = "perl" unless $target;
2270 $tmp = "." unless $tmp;
2272 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2273 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2274 # extralibs.all are computed correctly
2276 MAP_LINKCMD = $linkcmd
2277 MAP_PERLINC = @{$perlinc || []}
2279 join(" \\\n\t", reverse sort keys %static), "
2281 MAP_PRELIBS = $Config::Config{libs} $Config::Config{cryptlib}
2284 if (defined $libperl) {
2285 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2287 unless ($libperl && -f $lperl) { # Ilya's code...
2288 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2289 $libperl ||= "libperl$self->{LIB_EXT}";
2290 $libperl = "$dir/$libperl";
2291 $lperl ||= "libperl$self->{LIB_EXT}";
2292 $lperl = "$dir/$lperl";
2294 if (! -f $libperl and ! -f $lperl) {
2295 # We did not find a static libperl. Maybe there is a shared one?
2296 if ($^O eq 'solaris' or $^O eq 'sunos') {
2297 $lperl = $libperl = "$dir/$Config::Config{libperl}";
2298 # SUNOS ld does not take the full path to a shared library
2299 $libperl = '' if $^O eq 'sunos';
2303 print STDOUT "Warning: $libperl not found
2304 If you're going to build a static perl binary, make sure perl is installed
2305 otherwise ignore this warning\n"
2306 unless (-f $lperl || defined($self->{PERL_SRC}));
2310 MAP_LIBPERL = $libperl
2314 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2315 $self->{NOECHO}$self->{RM_F} \$\@
2316 $self->{NOECHO}\$(TOUCH) \$\@
2320 foreach $catfile (@$extra){
2321 push @m, "\tcat $catfile >> \$\@\n";
2323 # SUNOS ld does not take the full path to a shared library
2324 my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2326 # Brain dead solaris linker does not use LD_RUN_PATH?
2327 # This fixes dynamic extensions which need shared libs
2328 my $ldfrom = ($^O eq 'solaris')?
2329 join(' ', map "-R$_", split /:/, $self->{LD_RUN_PATH}):'';
2332 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2333 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) $ldfrom $llibperl \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2334 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2335 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2336 $self->{NOECHO}echo 'To remove the intermediate files say'
2337 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2339 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2341 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2344 $tmp/perlmain.c: $makefilename}, q{
2345 }.$self->{NOECHO}.q{echo Writing $@
2346 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2347 -e "writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)" > $@t && $(MV) $@t $@
2350 push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2351 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2356 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2357 -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2358 "Perl binary" "$(MAP_TARGET)" \
2359 MAP_STATIC "$(MAP_STATIC)" \
2360 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2361 MAP_LIBPERL "$(MAP_LIBPERL)" \
2362 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2367 inst_perl: pure_inst_perl doc_inst_perl
2369 pure_inst_perl: $(MAP_TARGET)
2370 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2375 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2383 Defines how to rewrite the Makefile.
2390 # We do not know what target was originally specified so we
2391 # must force a manual rerun to be sure. But as it should only
2392 # happen very rarely it is not a significant problem.
2394 $(OBJECT) : $(FIRST_MAKEFILE)
2395 ' if $self->{OBJECT};
2398 # We take a very conservative approach here, but it\'s worth it.
2399 # We move Makefile to Makefile.old here to avoid gnu make looping.
2400 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2401 }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2402 }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2403 -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2404 -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2405 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2406 }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2407 }.$self->{NOECHO}.q{echo "==> Please rerun the make command. <=="
2410 # To change behavior to :: would be nice, but would break Tk b9.02
2411 # so you find such a warning below the dist target.
2412 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2413 # }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2419 =item manifypods (o)
2421 Defines targets and routines to translate the pods into manpages and
2422 put them into the INST_* directories.
2427 my($self, %attribs) = @_;
2428 return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2431 if (defined $self->{PERL_SRC}) {
2432 $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2434 $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2436 unless ($self->perl_script($pod2man_exe)) {
2437 # No pod2man but some MAN3PODS to be installed
2440 Warning: I could not locate your pod2man program. Please make sure,
2441 your pod2man program is in your PATH before you execute 'make'
2444 $pod2man_exe = "-S pod2man";
2448 qq[POD2MAN_EXE = $pod2man_exe\n],
2449 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2450 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2451 $self->{MAKEFILE}, q[";' \\
2452 -e 'print "Manifying $$m{$$_}\n";' \\
2453 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2454 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2456 push @m, "\nmanifypods : ";
2457 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2460 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2461 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2462 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2469 Returns true, if the argument is likely to be a command.
2474 my($self,$file) = @_;
2475 return $file if -x $file && ! -d $file;
2479 =item maybe_command_in_dirs
2481 method under development. Not yet used. Ask Ilya :-)
2485 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
2486 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2487 my($self, $names, $dirs, $trace, $ver) = @_;
2489 foreach $dir (@$dirs){
2490 next unless defined $dir; # $self->{PERL_SRC} may be undefined
2491 foreach $name (@$names){
2493 if ($self->file_name_is_absolute($name)) { # /foo/bar
2495 } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2496 $abs = $self->catfile($dir, $name);
2498 $abs = $self->catfile($self->curdir, $name);
2500 print "Checking $abs for $name\n" if ($trace >= 2);
2501 next unless $tryabs = $self->maybe_command($abs);
2502 print "Substituting $tryabs instead of $abs\n"
2503 if ($trace >= 2 and $tryabs ne $abs);
2506 print "Executing $abs\n" if ($trace >= 2);
2507 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2508 print "Using PERL=$abs\n" if $trace;
2511 } else { # Do not look for perl
2518 =item needs_linking (o)
2520 Does this module need linking? Looks into subdirectory objects (see
2521 also has_link_code())
2528 $caller = (caller(0))[3];
2529 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2530 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2531 if ($self->has_link_code or $self->{MAKEAPERL}){
2532 $self->{NEEDS_LINKING} = 1;
2535 foreach $child (keys %{$self->{CHILDREN}}) {
2536 if ($self->{CHILDREN}->{$child}->needs_linking) {
2537 $self->{NEEDS_LINKING} = 1;
2541 return $self->{NEEDS_LINKING} = 0;
2546 misnamed method (will have to be changed). The MM_Unix method just
2547 returns the argument without further processing.
2549 On VMS used to insure that colons marking targets are preceded by
2550 space - most Unix Makes don't need this, but it's necessary under VMS
2551 to distinguish the target delimiter from a colon appearing as part of
2557 my($self,$text) = @_;
2563 parse a file and return what you think is $VERSION in this file set to
2568 my($self,$parsefile) = @_;
2572 open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2575 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2578 # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2579 next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2581 package ExtUtils::MakeMaker::_version;
2590 $result = eval($eval);
2591 die "Could not eval '$eval' in $parsefile: $@" if $@;
2592 $result = "undef" unless defined $result;
2602 Defines the string that is passed to recursive make calls in
2612 my($sep) = $Is_VMS ? ',' : '';
2615 foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2616 push @pasthru, "$key=\"\$($key)\"";
2619 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2625 Takes no argument, returns the environment variable PATH as an array.
2631 my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2632 my $path = $ENV{PATH};
2633 $path =~ s:\\:/:g if $Is_OS2;
2634 my @path = split $path_sep, $path;
2635 foreach(@path) { $_ = '.' if $_ eq '' }
2641 Takes one argument, a file name, and returns the file name, if the
2642 argument is likely to be a perl script. On MM_Unix this is true for
2643 any ordinary, readable file.
2648 my($self,$file) = @_;
2649 return $file if -r $file && -f _;
2653 =item perldepend (o)
2655 Defines the dependency from all *.h files that come with the perl
2664 # Check for unpropogated config.sh changes. Should never happen.
2665 # We do NOT just update config.h because that is not sufficient.
2666 # An out of date config.h is not fatal but complains loudly!
2667 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2668 -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2670 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2671 }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2672 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2673 } if $self->{PERL_SRC};
2675 return join "", @m unless $self->needs_linking;
2679 $(PERL_INC)/EXTERN.h $(PERL_INC)/gv.h $(PERL_INC)/pp.h \
2680 $(PERL_INC)/INTERN.h $(PERL_INC)/handy.h $(PERL_INC)/proto.h \
2681 $(PERL_INC)/XSUB.h $(PERL_INC)/hv.h $(PERL_INC)/regcomp.h \
2682 $(PERL_INC)/av.h $(PERL_INC)/keywords.h $(PERL_INC)/regexp.h \
2683 $(PERL_INC)/config.h $(PERL_INC)/mg.h $(PERL_INC)/scope.h \
2684 $(PERL_INC)/cop.h $(PERL_INC)/op.h $(PERL_INC)/sv.h \
2685 $(PERL_INC)/cv.h $(PERL_INC)/opcode.h $(PERL_INC)/unixish.h \
2686 $(PERL_INC)/dosish.h $(PERL_INC)/patchlevel.h $(PERL_INC)/util.h \
2687 $(PERL_INC)/embed.h $(PERL_INC)/perl.h $(PERL_INC)/iperlsys.h \
2688 $(PERL_INC)/form.h $(PERL_INC)/perly.h
2690 $(OBJECT) : $(PERL_HDRS)
2691 } if $self->{OBJECT};
2693 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2700 Returns the attribute C<PERM_RW> or the string C<644>.
2701 Used as the string that is passed
2702 to the C<chmod> command to set the permissions for read/writeable files.
2703 MakeMaker chooses C<644> because it has turned out in the past that
2704 relying on the umask provokes hard-to-track bugreports.
2705 When the return value is used by the perl function C<chmod>, it is
2706 interpreted as an octal value.
2711 shift->{PERM_RW} || "644";
2716 Returns the attribute C<PERM_RWX> or the string C<755>,
2717 i.e. the string that is passed
2718 to the C<chmod> command to set the permissions for executable files.
2724 shift->{PERM_RWX} || "755";
2729 Defines target that copies all files in the hash PM to their
2730 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2736 my($autodir) = $self->catdir('$(INST_LIB)','auto');
2738 pm_to_blib: $(TO_INST_PM)
2739 }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2740 "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2741 -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2742 }.$self->{NOECHO}.q{$(TOUCH) $@
2746 =item post_constants (o)
2748 Returns an empty string per default. Dedicated to overrides from
2749 within Makefile.PL after all constants have been defined.
2758 =item post_initialize (o)
2760 Returns an empty string per default. Used in Makefile.PLs to add some
2761 chunk of text to the Makefile after the object is initialized.
2765 sub post_initialize {
2772 Returns an empty string. Can be used in Makefile.PLs to write some
2773 text to the Makefile at the end.
2784 Check a path variable in $self from %Config, if it contains a prefix,
2785 and replace it with another one.
2787 Takes as arguments an attribute name, a search prefix and a
2788 replacement prefix. Changes the attribute in the object.
2793 my($self,$var,$sprefix,$rprefix) = @_;
2794 $self->{uc $var} ||= $Config{lc $var};
2795 $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2796 $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2801 Defines targets to run *.PL files.
2807 return "" unless $self->{PL_FILES};
2809 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2811 all :: $self->{PL_FILES}->{$plfile}
2812 $self->{NOECHO}\$(NOOP)
2814 $self->{PL_FILES}->{$plfile} :: $plfile
2815 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2823 Defines the realclean target.
2828 my($self, %attribs) = @_;
2831 # Delete temporary files (via clean) and also delete installed files
2832 realclean purge :: clean
2834 # realclean subdirectories first (already cleaned)
2835 my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2836 foreach(@{$self->{DIR}}){
2837 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2838 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2840 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2841 if( $self->has_link_code ){
2842 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2843 push(@m, " $self->{RM_F} \$(INST_STATIC)\n");
2845 push(@m, " $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
2846 my(@otherfiles) = ($self->{MAKEFILE},
2847 "$self->{MAKEFILE}.old"); # Makefiles last
2848 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2849 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
2850 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
2854 =item replace_manpage_separator
2856 Takes the name of a package, which may be a nested package, in the
2857 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2861 sub replace_manpage_separator {
2862 my($self,$man) = @_;
2869 Defines the static target.
2874 # --- Static Loading Sections ---
2878 ## $(INST_PM) has been moved to the all: target.
2879 ## It remains here for awhile to allow for old usage: "make static"
2880 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2881 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2882 '.$self->{NOECHO}.'$(NOOP)
2886 =item static_lib (o)
2888 Defines how to produce the *.a (or equivalent) files.
2894 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2895 # return '' unless $self->needs_linking(); #might be because of a subdir
2897 return '' unless $self->has_link_code;
2901 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2904 # If this extension has it's own library (eg SDBM_File)
2905 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2906 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2909 q{ $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2910 $(CHMOD) $(PERM_RWX) $@
2911 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2913 # Old mechanism - still available:
2915 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2916 } if $self->{PERL_SRC} && $self->{EXTRALIBS};
2919 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2923 =item staticmake (o)
2930 my($self, %attribs) = @_;
2933 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
2935 # And as it's not yet built, we add the current extension
2936 # but only if it has some C code (or XS code, which implies C code)
2937 if (@{$self->{C}}) {
2938 @static = $self->catfile($self->{INST_ARCHLIB},
2941 "$self->{BASEEXT}$self->{LIB_EXT}"
2945 # Either we determine now, which libraries we will produce in the
2946 # subdirectories or we do it at runtime of the make.
2948 # We could ask all subdir objects, but I cannot imagine, why it
2949 # would be necessary.
2951 # Instead we determine all libraries for the new perl at
2953 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2955 $self->makeaperl(MAKE => $self->{MAKEFILE},
2956 DIRS => \@searchdirs,
2959 TARGET => $self->{MAP_TARGET},
2961 LIBPERL => $self->{LIBPERL_A}
2967 Helper subroutine for subdirs
2972 my($self, $subdir) = @_;
2977 $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
2984 Defines targets to process subdirectories.
2989 # --- Sub-directory Sections ---
2992 # This method provides a mechanism to automatically deal with
2993 # subdirectories containing further Makefile.PL scripts.
2994 # It calls the subdir_x() method for each subdirectory.
2995 foreach $dir (@{$self->{DIR}}){
2996 push(@m, $self->subdir_x($dir));
2997 #### print "Including $dir subdirectory\n";
3001 # The default clean, realclean and test targets in this Makefile
3002 # have automatically been given entries for each subdir.
3006 push(@m, "\n# none")
3013 Defines the test targets.
3018 # --- Test and Installation Sections ---
3020 my($self, %attribs) = @_;
3021 my $tests = $attribs{TESTS};
3022 if (!$tests && -d 't') {
3023 $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3025 # note: 'test.pl' name is also hardcoded in init_dirscan()
3029 TEST_TYPE=test_\$(LINKTYPE)
3034 testdb :: testdb_\$(LINKTYPE)
3036 test :: \$(TEST_TYPE)
3038 push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3040 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3041 unless $tests or -f "test.pl" or @{$self->{DIR}};
3044 push(@m, "test_dynamic :: pure_all\n");
3045 push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3046 push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3049 push(@m, "testdb_dynamic :: pure_all\n");
3050 push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3053 # Occasionally we may face this degenerate target:
3054 push @m, "test_ : test_dynamic\n\n";
3056 if ($self->needs_linking()) {
3057 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3058 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3059 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3061 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3062 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3065 push @m, "test_static :: test_dynamic\n";
3066 push @m, "testdb_static :: testdb_dynamic\n";
3071 =item test_via_harness (o)
3073 Helper method to write the test targets
3077 sub test_via_harness {
3078 my($self, $perl, $tests) = @_;
3079 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3080 "\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";
3083 =item test_via_script (o)
3085 Other helper method for test.
3089 sub test_via_script {
3090 my($self, $perl, $script) = @_;
3091 $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3092 qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3096 =item tool_autosplit (o)
3098 Defines a simple perl call that runs autosplit. May be deprecated by
3103 sub tool_autosplit {
3104 # --- Tool Sections ---
3106 my($self, %attribs) = @_;
3108 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3110 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3111 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3115 =item tools_other (o)
3117 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3118 the Makefile. Also defines the perl programs MKPATH,
3119 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3126 my $bin_sh = $Config{sh} || '/bin/sh';
3131 for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3132 push @m, "$_ = $self->{$_}\n";
3136 # The following is a portable way to say mkdir -p
3137 # To see which directories are created, change the if 0 to if 1
3138 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3140 # This helps us to minimize the effect of the .exists files A yet
3141 # better solution would be to have a stable file in the perl
3142 # distribution with a timestamp of zero. But this solution doesn't
3143 # need any changes to the core distribution and works with older perls
3144 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3148 return join "", @m if $self->{PARENT};
3151 # Here we warn users that an old packlist file was found somewhere,
3152 # and that they should call some uninstall routine
3153 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3154 -e 'print "WARNING: I have found an old package in\n";' \\
3155 -e 'print "\t$$ARGV[0].\n";' \\
3156 -e 'print "Please make sure the two installations are not conflicting\n";'
3161 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3162 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3164 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3165 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3166 -e 'print "=over 4";' \
3167 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3170 UNINSTALL = $(PERL) -MExtUtils::Install \
3171 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3172 -e 'print " packlist above carefully.\n There may be errors. Remove the";' \
3173 -e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
3179 =item tool_xsubpp (o)
3181 Determines typemaps, xsubpp version, prototype behaviour.
3187 return "" unless $self->needs_linking;
3188 my($xsdir) = $self->catdir($self->{PERL_LIB},"ExtUtils");
3189 my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3190 if( $self->{TYPEMAPS} ){
3192 foreach $typemap (@{$self->{TYPEMAPS}}){
3193 if( ! -f $typemap ){
3194 warn "Typemap $typemap not found.\n";
3197 push(@tmdeps, $typemap);
3201 push(@tmdeps, "typemap") if -f "typemap";
3202 my(@tmargs) = map("-typemap $_", @tmdeps);
3203 if( exists $self->{XSOPT} ){
3204 unshift( @tmargs, $self->{XSOPT} );
3208 my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3210 # What are the correct thresholds for version 1 && 2 Paul?
3211 if ( $xsubpp_version > 1.923 ){
3212 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3214 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3215 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3216 Your version of xsubpp is $xsubpp_version and cannot handle this.
3217 Please upgrade to a more recent version of xsubpp.
3220 $self->{XSPROTOARG} = "";
3224 $xsubpp = $self->{CAPI} ? "xsubpp -object_capi" : "xsubpp";
3228 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3229 XSPROTOARG = $self->{XSPROTOARG}
3230 XSUBPPDEPS = @tmdeps
3231 XSUBPPARGS = @tmargs
3237 my($self,$xsubpp) = @_;
3238 return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3242 # try to figure out the version number of the xsubpp on the system
3244 # first try the -v flag, introduced in 1.921 & 2.000a2
3246 return "" unless $self->needs_linking;
3248 my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3249 print "Running $command\n" if $Verbose >= 2;
3250 $version = `$command` ;
3251 warn "Running '$command' exits with status " . ($?>>8) if $?;
3254 return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3256 # nope, then try something else
3258 my $counter = '000';
3259 my ($file) = 'temp' ;
3260 $counter++ while -e "$file$counter"; # don't overwrite anything
3263 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3265 MODULE = fred PACKAGE = fred
3274 $command = "$self->{PERL} $xsubpp $file 2>&1";
3275 print "Running $command\n" if $Verbose >= 2;
3276 my $text = `$command` ;
3277 warn "Running '$command' exits with status " . ($?>>8) if $?;
3280 # gets 1.2 -> 1.92 and 2.000a1
3281 return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
3283 # it is either 1.0 or 1.1
3284 return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3286 # none of the above, so 1.0
3287 return $Xsubpp_Version = "1.0" ;
3290 =item top_targets (o)
3292 Defines the targets all, subdirs, config, and O_FILES
3297 # --- Target Sections ---
3302 #all :: config $(INST_PM) subdirs linkext manifypods
3306 all :: pure_all manifypods
3307 '.$self->{NOECHO}.'$(NOOP)
3309 unless $self->{SKIPHASH}{'all'};
3312 pure_all :: config pm_to_blib subdirs linkext
3313 '.$self->{NOECHO}.'$(NOOP)
3315 subdirs :: $(MYEXTLIB)
3316 '.$self->{NOECHO}.'$(NOOP)
3318 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3319 '.$self->{NOECHO}.'$(NOOP)
3321 config :: $(INST_ARCHAUTODIR)/.exists
3322 '.$self->{NOECHO}.'$(NOOP)
3324 config :: $(INST_AUTODIR)/.exists
3325 '.$self->{NOECHO}.'$(NOOP)
3329 config :: Version_check
3330 $self->{NOECHO}\$(NOOP)
3332 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3334 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3336 if (%{$self->{MAN1PODS}}) {
3338 config :: \$(INST_MAN1DIR)/.exists
3339 $self->{NOECHO}\$(NOOP)
3342 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3344 if (%{$self->{MAN3PODS}}) {
3346 config :: \$(INST_MAN3DIR)/.exists
3347 $self->{NOECHO}\$(NOOP)
3350 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3354 $(O_FILES): $(H_FILES)
3355 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3359 perldoc ExtUtils::MakeMaker
3364 }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3365 -MExtUtils::MakeMaker=Version_check \
3366 -e "Version_check('$(MM_VERSION)')"
3374 Obsolete, depecated method. Not used since Version 5.21.
3379 # --- perllocal.pod section ---
3380 my($self,$what,$name,@attribs)=@_;
3381 my $time = localtime;
3382 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3383 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3384 print "\n\n=back\n\n";
3389 Defines the suffix rules to compile XS files to C.
3395 return '' unless $self->needs_linking();
3398 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3404 Defines suffix rules to go from XS to object files directly. This is
3405 only intended for broken make implementations.
3409 sub xs_o { # many makes are too dumb to use xs_c then c_o
3411 return '' unless $self->needs_linking();
3414 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3415 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3421 This is internal method that returns path to libperl.a equivalent
3422 to be linked to dynamic extensions. UNIX does not have one but OS2
3434 This is internal method that returns name of a file that is
3435 passed to linker to define symbols to be exported.
3436 UNIX does not have one but OS2 and Win32 do.
3452 L<ExtUtils::MakeMaker>