1 package ExtUtils::MakeMaker::TieAtt;
2 # this package will go away again, when we don't have modules around
3 # anymore that import %att It ties an empty %att and records in which
4 # object this %att was tied. FETCH and STORE return/store-to the
5 # appropriate value from %$self
7 # the warndirectuse method warns if somebody calls MM->something. It
8 # has nothing to do with the tie'd %att.
13 bless { SECRETHASH => $_[1]};
17 print "Warning (non-fatal): Importing of %att is deprecated [$_[1]]
18 use \$self instead\n" unless ++$Enough>$Enough_limit;
19 print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
20 $_[0]->{SECRETHASH}->{$_[1]};
24 print "Warning (non-fatal): Importing of %att is deprecated [$_[1]][$_[2]]
25 use \$self instead\n" unless ++$Enough>$Enough_limit;
26 print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
27 $_[0]->{SECRETHASH}->{$_[1]} = $_[2];
31 print "Warning (non-fatal): Importing of %att is deprecated [FIRSTKEY]
32 use \$self instead\n" unless ++$Enough>$Enough_limit;
33 print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
34 each %{$_[0]->{SECRETHASH}};
38 each %{$_[0]->{SECRETHASH}};
46 return if $Enough>$Enough_limit;
47 print STDOUT "Warning (non-fatal): Direct use of class methods deprecated; use\n";
48 my($method) = $caller =~ /.*:(\w+)$/;
51 $self->MM::', $method, "();
53 print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n"
54 if ++$Enough==$Enough_limit;
57 package ExtUtils::MakeMaker;
59 # Last edited $Date: 1995/12/10 23:38:09 $ by Andreas Koenig
60 # $Id: MakeMaker.pm,v 1.116 1995/12/10 23:38:09 k Exp $
62 $Version = $VERSION = "5.12";
64 $ExtUtils::MakeMaker::Version_OK = 4.13; # Makefiles older than $Version_OK will die
65 # (Will be checked from MakeMaker version 4.13 onwards)
71 require ExtUtils::Manifest;
72 require ExtUtils::Liblist;
75 eval {require DynaLoader;}; # Get mod2fname, if defined. Will fail
78 # print join "**\n**", "", %INC, "";
84 @EXPORT = qw(&WriteMakefile &writeMakefile $Verbose &prompt);
85 @EXPORT_OK = qw($Version $VERSION &Version_check
86 &help &neatvalue &mkbootstrap &mksymlists
87 %att ## Import of %att is deprecated, please use OO features!
90 $Is_VMS = $Config::Config{osname} eq 'VMS';
91 require ExtUtils::MM_VMS if $Is_VMS;
92 $Is_OS2 = $Config::Config{osname} =~ m|^os/?2$|i ;
93 $ENV{EMXSHELL} = 'sh' if $Is_OS2; # to run `commands`
95 $ExtUtils::MakeMaker::Verbose = 0 unless defined $ExtUtils::MakeMaker::Verbose;
97 #$SIG{__DIE__} = sub { print @_, Carp::longmess(); die; };
98 ####$SIG{__WARN__} = sub { print Carp::longmess(); warn @_; };
99 $SIG{__WARN__} = sub {
100 $_[0] =~ /^Use of uninitialized value/ && return;
101 $_[0] =~ /used only once/ && return;
102 $_[0] =~ /^Subroutine\s+[\w:]+\s+redefined/ && return;
106 # Setup dummy package:
107 # MY exists for overriding methods to be defined within
108 unshift(@MY::ISA, qw(MM));
110 # Dummy package MM inherits actual methods from OS-specific
111 # default packages. We use this intermediate package so
112 # MY::XYZ->func() can call MM->func() and get the proper
113 # default routine without having to know under what OS
116 @MM::ISA = qw[MM_Unix ExtUtils::MakeMaker];
117 unshift @MM::ISA, 'ExtUtils::MM_VMS' if $Is_VMS;
118 unshift @MM::ISA, 'ExtUtils::MM_OS2' if $Is_OS2;
121 @ExtUtils::MakeMaker::MM_Sections_spec = (
122 post_initialize => {},
125 const_loadlibs => {},
126 const_cccmd => {}, # the last but one addition here (CONST_CCCMD)
127 tool_autosplit => {},
132 post_constants => {},
137 top_targets => {}, # currently the last section that adds a key to $self (DIR_TARGET)
161 staticmake => {}, # Sadly this defines more macros
163 postamble => {}, # should always be last the user has hands on
164 selfdocument => {}, # well, he may override it, but he won't do it
166 # looses section ordering
167 %ExtUtils::MakeMaker::MM_Sections = @ExtUtils::MakeMaker::MM_Sections_spec;
169 @ExtUtils::MakeMaker::MM_Sections = grep(!ref, @ExtUtils::MakeMaker::MM_Sections_spec);
171 %ExtUtils::MakeMaker::Recognized_Att_Keys = %ExtUtils::MakeMaker::MM_Sections; # All sections are valid keys.
173 @ExtUtils::MakeMaker::Get_from_Config = qw(
191 foreach $item (split(/\n/,attrib_help())){
192 next unless $item =~ m/^=item\s+(\w+)\s*$/;
193 $ExtUtils::MakeMaker::Recognized_Att_Keys{$1} = $2;
194 print "Attribute '$1' => '$2'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
196 foreach $item (@ExtUtils::MakeMaker::Get_from_Config) {
197 next unless $Config::Config{$item};
198 $ExtUtils::MakeMaker::Recognized_Att_Keys{uc $item} = $Config::Config{$item};
199 print "Attribute '\U$item\E' => '$Config::Config{$item}'\n"
200 if ($ExtUtils::MakeMaker::Verbose >= 2);
203 %ExtUtils::MakeMaker::Prepend_dot_dot = qw(
204 INST_LIB 1 INST_ARCHLIB 1 INST_EXE 1 MAP_TARGET 1 INST_MAN1DIR 1 INST_MAN3DIR 1
205 PERL_SRC 1 PERL 1 FULLPERL 1
207 $PACKNAME = "PACK000";
212 The extension you are trying to build apparently is rather old and
213 most probably outdated. We detect that from the fact, that a
214 subroutine "writeMakefile" is called, and this subroutine is not
215 supported anymore since about October 1994.
217 Please contact the author or look into CPAN (details about CPAN can be
218 found in the FAQ and at http:/www.perl.com) for a more recent version
219 of the extension. If you're really desperate, you can try to change
220 the subroutine name from writeMakefile to WriteMakefile and rerun
221 'perl Makefile.PL', but you're most probably left alone, when you do
230 Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
232 MM->new(\%att)->flush;
236 my($class,$self) = @_;
239 print STDOUT "MakeMaker (v$ExtUtils::MakeMaker::VERSION)\n" if $ExtUtils::MakeMaker::Verbose;
240 if (-f "MANIFEST" && ! -f "Makefile"){
244 $self = {} unless (defined $self);
248 my(%initial_att) = %$self; # record initial attributes
250 if (defined $self->{CONFIGURE}) {
251 if (ref $self->{CONFIGURE} eq 'CODE') {
252 $self = { %$self, %{&{$self->{CONFIGURE}}}};
254 croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n";
258 # This is for old Makefiles written pre 5.00, will go away
259 if ( Carp::longmess("") =~ /runsubdirpl/s ){
260 $self->{Correct_relativ_directories}++;
262 $self->{Correct_relativ_directories}=0;
265 my $class = ++$PACKNAME;
268 print "Blessing Object into class [$class]\n" if $ExtUtils::MakeMaker::Verbose;
269 mv_all_methods("MY",$class);
271 ######## tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
272 push @ExtUtils::MakeMaker::Parent, $self;
273 @{"$class\:\:ISA"} = 'MM';
276 if (defined $ExtUtils::MakeMaker::Parent[-2]){
277 $self->{PARENT} = $ExtUtils::MakeMaker::Parent[-2];
279 for $key (keys %ExtUtils::MakeMaker::Prepend_dot_dot) {
280 next unless defined $self->{PARENT}{$key};
281 $self->{$key} = $self->{PARENT}{$key};
282 $self->{$key} = $self->catdir("..",$self->{$key})
283 unless $self->{$key} =~ m!^/!;
285 $self->{PARENT}->{CHILDREN}->{$class} = $self if $self->{PARENT};
287 parse_args($self,@ARGV);
290 $self->{NAME} ||= $self->guess_name;
292 ($self->{NAME_SYM} = $self->{NAME}) =~ s/\W+/_/g;
296 if (! $self->{PERL_SRC} &&
297 $INC{'Config.pm'} ne $self->catdir($Config::Config{archlibexp},'Config.pm')){
298 (my $pthinks = $INC{'Config.pm'}) =~ s!/Config\.pm$!!;
301 Your perl and your Config.pm seem to have different ideas about the architecture
303 Perl thinks: [$pthinks]
304 Config says: [$Config::Config{archname}]
305 This may or may not cause problems. Please check your installation of perl if you
306 have problems building this extension.
310 $self->init_dirscan();
311 $self->init_others();
313 push @{$self->{RESULT}}, <<END;
314 # This Makefile is for the $self->{NAME} extension to perl.
316 # It was generated automatically by MakeMaker version $ExtUtils::MakeMaker::VERSION from the contents
317 # of Makefile.PL. Don't edit this file, edit Makefile.PL instead.
319 # ANY CHANGES MADE HERE WILL BE LOST!
321 # MakeMaker Parameters:
324 foreach $key (sort keys %initial_att){
325 my($v) = neatvalue($initial_att{$key});
326 $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
328 push @{$self->{RESULT}}, "# $key => $v";
331 # turn the SKIP array into a SKIPHASH hash
333 for $skip (@{$self->{SKIP} || []}) {
334 $self->{SKIPHASH}{$skip} = 1;
337 # We run all the subdirectories now. They don't have much to query
338 # from the parent, but the parent has to query them: if they need linking!
340 unless ($self->{NORECURS}) {
341 foreach $dir (@{$self->{DIR}}){
345 open FH, "Makefile.PL";
352 tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
354 foreach $section ( @ExtUtils::MakeMaker::MM_Sections ){
355 print "Processing Makefile '$section' section\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
356 my($skipit) = $self->skipcheck($section);
358 push @{$self->{RESULT}}, "\n# --- MakeMaker $section section $skipit.";
360 my(%a) = %{$self->{$section} || {}};
361 push @{$self->{RESULT}}, "\n# --- MakeMaker $section section:";
362 push @{$self->{RESULT}}, "# " . join ", ", %a if $ExtUtils::MakeMaker::Verbose && %a;
363 push @{$self->{RESULT}}, $self->nicetext($self->$section( %a ));
367 push @{$self->{RESULT}}, "\n# End.";
368 ######## untie %::att;
369 pop @ExtUtils::MakeMaker::Parent;
375 eval {require ExtUtils::Manifest};
377 print STDOUT "Warning: you have not installed the ExtUtils::Manifest
378 module -- skipping check of the MANIFEST file\n";
380 print STDOUT "Checking if your kit is complete...\n";
381 $ExtUtils::Manifest::Quiet=$ExtUtils::Manifest::Quiet=1; #avoid warning
382 my(@missed)=ExtUtils::Manifest::manicheck();
384 print STDOUT "Warning: the following files are missing in your kit:\n";
385 print "\t", join "\n\t", @missed;
387 print STDOUT "Please inform the author.\n";
389 print STDOUT "Looks good\n";
395 my($self, @args) = @_;
397 unless (m/(.*?)=(.*)/){
398 help(),exit 1 if m/^help$/;
399 ++$ExtUtils::MakeMaker::Verbose if m/^verb/;
402 my($name, $value) = ($1, $2);
403 if ($value =~ m/^~(\w+)?/){ # tilde with optional username
404 $value =~ s [^~(\w*)]
406 ((getpwnam($1))[7] || "~$1") :
410 # This may go away, in mid 1996
411 if ($self->{Correct_relativ_directories}){
412 $value = $self->catdir("..",$value)
413 if $ExtUtils::MakeMaker::Prepend_dot_dot{$name} && ! $value =~ m!^/!;
415 $self->{$name} = $value;
417 # This may go away, in mid 1996
418 delete $self->{Correct_relativ_directories};
420 # catch old-style 'potential_libs' and inform user how to 'upgrade'
421 if (defined $self->{potential_libs}){
422 my($msg)="'potential_libs' => '$self->{potential_libs}' should be";
423 if ($self->{potential_libs}){
424 print STDOUT "$msg changed to:\n\t'LIBS' => ['$self->{potential_libs}']\n";
426 print STDOUT "$msg deleted.\n";
428 $self->{LIBS} = [$self->{potential_libs}];
429 delete $self->{potential_libs};
431 # catch old-style 'ARMAYBE' and inform user how to 'upgrade'
432 if (defined $self->{ARMAYBE}){
433 my($armaybe) = $self->{ARMAYBE};
434 print STDOUT "ARMAYBE => '$armaybe' should be changed to:\n",
435 "\t'dynamic_lib' => {ARMAYBE => '$armaybe'}\n";
436 my(%dl) = %{$self->{dynamic_lib} || {}};
437 $self->{dynamic_lib} = { %dl, ARMAYBE => $armaybe};
438 delete $self->{ARMAYBE};
440 if (defined $self->{LDTARGET}){
441 print STDOUT "LDTARGET should be changed to LDFROM\n";
442 $self->{LDFROM} = $self->{LDTARGET};
443 delete $self->{LDTARGET};
445 # Turn a DIR argument on the command line into an array
446 if (defined $self->{DIR} && ref \$self->{DIR} eq 'SCALAR') {
447 # So they can choose from the command line, which extensions they want
448 # the grep enables them to have some colons too much in case they
449 # have to build a list with the shell
450 $self->{DIR} = [grep $_, split ":", $self->{DIR}];
453 foreach $mmkey (sort keys %$self){
454 print STDOUT " $mmkey => ", neatvalue($self->{$mmkey}), "\n" if $ExtUtils::MakeMaker::Verbose;
455 print STDOUT "'$mmkey' is not a known MakeMaker parameter name.\n"
456 unless exists $ExtUtils::MakeMaker::Recognized_Att_Keys{$mmkey};
462 # We allow extension-specific hints files.
464 return unless -d "hints";
466 # First we look for the best hintsfile we have
468 my($hint)="$Config::Config{osname}_$Config::Config{osvers}";
473 # Also try without trailing minor version numbers.
475 last if -f "hints/$hint.pl"; # found
477 last unless $hint =~ s/_[^_]*$//; # nothing to cut off
479 return unless -f "hints/$hint.pl"; # really there
481 # execute the hintsfile:
483 open HINTS, "hints/$hint.pl";
484 @goodhints = <HINTS>;
486 print STDOUT "Processing hints file hints/$hint.pl\n";
487 eval join('',@goodhints);
488 print STDOUT $@ if $@;
496 # Here you see the *current* list of methods that are overridable
497 # from Makefile.PL via MY:: subroutines. As of VERSION 5.07 I'm
498 # still trying to reduce the list to some reasonable minimum --
499 # because I want to make it easier for the user. A.K.
501 foreach $method (@ExtUtils::MakeMaker::MM_Sections, qw[ dir_target
502 exescan fileparse fileparse_set_fstype installpm_x libscan makeaperl
503 mksymlists needs_linking runsubdirpl subdir_x test_via_harness
504 test_via_script writedoc ]) {
506 # We cannot say "next" here. Nick might call MY->makeaperl
507 # which isn't defined right now
509 # next unless defined &{"${from}::$method"};
511 *{"${to}::$method"} = \&{"${from}::$method"};
512 my $symtab = \%{"${from}::"};
514 # delete would do, if we were sure, nobody ever called
515 # MY->makeaperl directly
517 # delete $symtab->{$method};
519 # If we delete a method, then it will be undefined and cannot
520 # be called. But as long as we have Makefile.PLs that rely on
521 # %MY:: being intact, we have to fill the hole with an
524 eval "package MY; sub $method {local *$method; shift->MY::$method(\@_); }";
528 # We have to clean out %INC also, because the current directory is
529 # changed frequently and Graham Barr prefers to get his version
530 # out of a History.pl file which is "required" so woudn't get
531 # loaded again in another extension requiring a History.pl
534 foreach $inc (keys %INC) {
535 next if $ExtUtils::MakeMaker::NORMAL_INC{$inc};
536 #warn "***$inc*** deleted";
544 BEGIN { my $ISA_TTY = -t STDIN && -t STDOUT }
545 Carp::confess("prompt function called without an argument") unless defined $mess;
546 $def = "" unless defined $def;
547 my $dispdef = "[$def] ";
551 print "$mess $dispdef";
552 chop($ans = <STDIN>);
554 return $ans if defined $ans;
559 return $Attrib_Help if $Attrib_Help;
564 #### local $/ = ""; # bug in 5.001m
565 open POD, $INC{"ExtUtils/MakeMaker.pm"}
566 or die "Open $INC{'ExtUtils/MakeMaker.pm'}: $!";
567 while ($line = <POD>) {
568 $switch ||= $line =~ /^=item C\s*$/;
570 last if $line =~ /^=cut/;
574 $Attrib_Help = $help;
577 sub help {print &attrib_help, "\n";}
582 if ($section eq 'dynamic') {
583 print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
584 "in skipped section 'dynamic_bs'\n"
585 if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
586 print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
587 "in skipped section 'dynamic_lib'\n"
588 if $self->{SKIPHASH}{dynamic_lib} && $ExtUtils::MakeMaker::Verbose;
590 if ($section eq 'dynamic_lib') {
591 print STDOUT "Warning (non-fatal): Target '\$(INST_DYNAMIC)' depends on ",
592 "targets in skipped section 'dynamic_bs'\n"
593 if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
595 if ($section eq 'static') {
596 print STDOUT "Warning (non-fatal): Target 'static' depends on targets ",
597 "in skipped section 'static_lib'\n"
598 if $self->{SKIPHASH}{static_lib} && $ExtUtils::MakeMaker::Verbose;
600 return 'skipped' if $self->{SKIPHASH}{$section};
608 print STDOUT "Writing $self->{MAKEFILE} for $self->{NAME}\n";
610 unlink($self->{MAKEFILE}, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : '');
611 open MAKE, ">MakeMaker.tmp" or die "Unable to open MakeMaker.tmp: $!";
613 for $chunk (@{$self->{RESULT}}) {
614 print MAKE "$chunk\n";
618 my($finalname) = $Is_VMS ? "Descrip.MMS" : $self->{MAKEFILE};
619 rename("MakeMaker.tmp", $finalname);
620 chmod 0644, $finalname;
621 system("$Config::Config{eunicefix} $finalname") unless $Config::Config{eunicefix} eq ":";
625 my($checkversion) = @_;
626 die "Your Makefile was built with ExtUtils::MakeMaker v $checkversion.
627 Current Version is $ExtUtils::MakeMaker::VERSION. There have been considerable
628 changes in the meantime.
629 Please rerun 'perl Makefile.PL' to regenerate the Makefile.\n"
630 if $checkversion < $ExtUtils::MakeMaker::Version_OK;
631 printf STDOUT "%s %s %s %s.\n", "Makefile built with ExtUtils::MakeMaker v",
632 $checkversion, "Current Version is", $ExtUtils::MakeMaker::VERSION
633 unless $checkversion == $ExtUtils::MakeMaker::VERSION;
640 tie %att, ExtUtils::MakeMaker::TieAtt, $self;
641 $self->parse_args(@ARGV);
642 $self->mksymlists(@_);
645 # The following mkbootstrap() is only for installations that are calling
646 # the pre-4.1 mkbootstrap() from their old Makefiles. This MakeMaker
647 # writes Makefiles, that use ExtUtils::Mkbootstrap directly.
650 !!! Your Makefile has been built such a long time ago, !!!
651 !!! that is unlikely to work with current MakeMaker. !!!
652 !!! Please rebuild your Makefile !!!
658 return "undef" unless defined $v;
660 return "'$v'" unless $t;
662 my(@m, $elem, @neat);
664 foreach $elem (@$v) {
665 push @neat, "'$elem'";
667 push @m, join ", ", @neat;
671 return "$v" unless $t eq 'HASH';
673 push(@m,"$key=>".neatvalue($val)) while (($key,$val) = each %$v);
674 return "{ ".join(', ',@m)." }";
680 if ($ExtUtils::MakeMaker::Verbose){
681 push @m, "\n# Full list of MakeMaker attribute values:";
682 foreach $key (sort keys %$self){
683 next if $key eq 'RESULT' || $key =~ /^[A-Z][a-z]/;
684 my($v) = neatvalue($self->{$key});
685 $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
687 push @m, "# $key => $v";
695 ## ## ## ## # # # # # # #
696 # # # # # # # # # # ## # # # #
697 # # # # # # # # # # # # ##
698 # # # # # # # # # # ##
699 # # # # # # # ## # # #
700 # # # # ####### ##### # # # # #
709 Exporter::import('ExtUtils::MakeMaker',
712 # These attributes cannot be overridden externally
713 @Other_Att_Keys{qw(EXTRALIBS BSLOADLIBS LDLOADLIBS)} = (1) x 3;
715 if ($Is_VMS = $Config::Config{osname} eq 'VMS') {
716 require VMS::Filespec;
717 import VMS::Filespec 'vmsify';
720 $Is_OS2 = $ExtUtils::MakeMaker::Is_OS2;
722 sub guess_name { # Charles! That's something for MM_VMS
724 my $name = fastcwd();
726 $name =~ s:.*?([^.\]]+)\]:$1: unless ($name =~ s:.*[.\[]ext\.(.*)\]:$1:i);
727 $name =~ s#[.\]]#::#g;
729 $name =~ s:.*/:: unless ($name =~ s:^.*/ext/::);
731 $name =~ s#\-\d+\.\d+$##; # this is new with MM 5.00
739 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
740 $self = $ExtUtils::MakeMaker::Parent[-1];
743 # --- Initialize Module Name and Paths
745 # NAME = The perl module name for this extension (eg DBD::Oracle).
746 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
747 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
748 # ROOTEXT = Directory part of FULLEXT with leading /.
750 $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
752 # Copied from DynaLoader:
754 my(@modparts) = split(/::/,$self->{NAME});
755 my($modfname) = $modparts[-1];
757 # Some systems have restrictions on files names for DLL's etc.
758 # mod2fname returns appropriate file base name (typically truncated)
759 # It may also edit @modparts if required.
760 if (defined &DynaLoader::mod2fname) {
761 $modfname = &DynaLoader::mod2fname(\@modparts);
762 } elsif ($Is_OS2) { # Need manual correction if run with miniperl:-(
763 $modfname = substr($modfname, 0, 7) . '_';
768 $self->{NAME}) =~ s!.*::!! ; #eg. Socket
770 if (defined &DynaLoader::mod2fname or $Is_OS2) {
771 # As of 5.001m, dl_os2 appends '_'
772 $self->{DLBASE} = $modfname; #eg. Socket_
774 $self->{DLBASE} = '$(BASEEXT)';
778 $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
780 $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
783 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
785 # *Real* information: where did we get these two from? ...
786 my $inc_config_dir = dirname($INC{'Config.pm'});
787 my $inc_carp_dir = dirname($INC{'Carp.pm'});
789 # Typically PERL_* and INST_* will be identical but that need
790 # not be the case (e.g., installing into project libraries etc).
792 # Perl Macro: With source No source
793 # PERL_SRC ../.. (undefined)
794 # PERL_LIB PERL_SRC/lib $Config{privlibexp}
795 # PERL_ARCHLIB PERL_SRC/lib $Config{archlibexp}
797 # INST Macro: For standard for any other
799 # INST_LIB PERL_SRC/lib ./blib
800 # INST_ARCHLIB PERL_SRC/lib ./blib/<archname>
802 unless ($self->{PERL_SRC}){
804 foreach $dir (qw(.. ../.. ../../..)){
805 if ( -f "$dir/config.sh"
807 && -f "$dir/lib/Exporter.pm") {
808 $self->{PERL_SRC}=$dir ;
813 if ($self->{PERL_SRC}){
814 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
815 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
816 $self->{PERL_INC} = $self->{PERL_SRC};
817 # catch an situation that has occurred a few times in the past:
818 warn <<EOM unless -s "$self->{PERL_SRC}/cflags";
819 You cannot build extensions below the perl source tree after executing
820 a 'make clean' in the perl source tree.
822 To rebuild extensions distributed with the perl source you should
823 simply Configure (to include those extensions) and then build perl as
824 normal. After installing perl the source tree can be deleted. It is not
825 needed for building extensions.
827 It is recommended that you unpack and build additional extensions away
828 from the perl source tree.
831 # we should also consider $ENV{PERL5LIB} here
832 $self->{PERL_LIB} = $Config::Config{privlibexp} unless $self->{PERL_LIB};
833 $self->{PERL_ARCHLIB} = $Config::Config{archlibexp} unless $self->{PERL_ARCHLIB};
834 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
836 die <<EOM unless (-f ($perl_h = $self->catfile("$self->{PERL_INC}","perl.h")));
837 Error: Unable to locate installed Perl libraries or Perl source code.
839 It is recommended that you install perl in a standard location before
840 building extensions. You can say:
842 $^X Makefile.PL PERL_SRC=/path/to/perl/source/directory
844 if you have not yet installed perl but still want to build this
846 (You get this message, because MakeMaker could not find "$perl_h")
849 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
850 # if $Verbose && $self->needs_linking();
854 # INST_LIB typically pre-set if building an extension after
855 # perl has been built and installed. Setting INST_LIB allows
856 # you to build directly into, say $Config::Config{privlibexp}.
857 unless ($self->{INST_LIB}){
860 ##### XXXXX We have to change this nonsense
862 if (defined $self->{PERL_SRC}) {
863 $self->{INST_LIB} = $self->{PERL_LIB};
865 $self->{INST_LIB} = $self->catdir(".","blib");
868 # Try to work out what INST_ARCHLIB should be if not set:
869 unless ($self->{INST_ARCHLIB}){
871 # our private build lib
872 $self->catdir(".","blib") =>
873 $self->catdir(".","blib",$Config::Config{archname}),
874 $self->{PERL_LIB} => $self->{PERL_ARCHLIB},
875 $Config::Config{privlibexp} => $Config::Config{archlibexp},
876 $inc_carp_dir => $inc_config_dir,
878 $self->{INST_ARCHLIB} = $archmap{$self->{INST_LIB}};
879 unless($self->{INST_ARCHLIB}){
880 # Oh dear, we'll have to default it and warn the user
881 my($archname) = $Config::Config{archname};
882 if (-d "$self->{INST_LIB}/$archname"){
883 $self->{INST_ARCHLIB} = $self->catdir("$self->{INST_LIB}","$archname");
884 print STDOUT "Defaulting INST_ARCHLIB to $self->{INST_ARCHLIB}\n";
886 $self->{INST_ARCHLIB} = $self->{INST_LIB};
890 $self->{INST_EXE} ||= $self->catdir('.','blib',$Config::Config{archname});
892 if ($self->{PREFIX}){
893 # With perl5.002 it turns out, that we hardcoded some assumptions in here:
894 # $self->{INSTALLPRIVLIB} = $self->catdir($self->{PREFIX},"lib","perl5");
895 # $self->{INSTALLBIN} = $self->catdir($self->{PREFIX},"bin");
896 # $self->{INSTALLMAN3DIR} = $self->catdir($self->{PREFIX},"perl5","man","man3")
897 # unless defined $self->{INSTALLMAN3DIR};
899 # we have to look at the relation between $Config{prefix} and
900 # the requested values
901 ($self->{INSTALLPRIVLIB} = $Config{installprivlib})
902 =~ s/\Q$Config{prefix}\E/$self->{PREFIX}/;
903 ($self->{INSTALLBIN} = $Config{installbin})
904 =~ s/\Q$Config{prefix}\E/$self->{PREFIX}/;
905 ($self->{INSTALLMAN3DIR} = $Config{installman3dir})
906 =~ s/\Q$Config{prefix}\E/$self->{PREFIX}/;
909 if( $self->{INSTALLPRIVLIB} && ! $self->{INSTALLARCHLIB} ){
910 # Same as above here. With the unresolved versioned directory issue, we have to
911 # be more careful to follow Configure
912 # my($archname) = $Config::Config{archname};
913 # if (-d $self->catdir($self->{INSTALLPRIVLIB},$archname)){
914 # $self->{INSTALLARCHLIB} = $self->catdir($self->{INSTALLPRIVLIB},$archname);
915 # print STDOUT "Defaulting INSTALLARCHLIB to $self->{INSTALLARCHLIB}\n";
917 # $self->{INSTALLARCHLIB} = $self->{INSTALLPRIVLIB};
919 ($self->{INSTALLARCHLIB} = $Config{installarchlib})
920 =~ s/\Q$Config{installprivlib}\E/$self->{INSTALLPRIVLIB}/;
921 if (-d $self->{INSTALLARCHLIB}) {
922 print STDOUT "Defaulting INSTALLARCHLIB to $self->{INSTALLARCHLIB}\n";
924 $self->{INSTALLARCHLIB} = $self->{INSTALLPRIVLIB};
928 $self->{INSTALLPRIVLIB} ||= $Config::Config{installprivlib};
929 $self->{INSTALLARCHLIB} ||= $Config::Config{installarchlib};
930 $self->{INSTALLBIN} ||= $Config::Config{installbin};
932 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
933 unless defined $self->{INSTALLMAN1DIR};
934 unless (defined $self->{INST_MAN1DIR}){
935 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
936 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
938 $self->{INST_MAN1DIR} = $self->catdir('.','blib','man','man1');
941 $self->{MAN1EXT} ||= $Config::Config{man1ext};
943 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
944 unless defined $self->{INSTALLMAN3DIR};
945 unless (defined $self->{INST_MAN3DIR}){
946 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
947 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
949 $self->{INST_MAN3DIR} = $self->catdir('.','blib','man','man3');
952 $self->{MAN3EXT} ||= $Config::Config{man3ext};
954 print STDOUT "CONFIG must be an array ref\n"
955 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
956 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
957 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
958 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
960 foreach $m (@{$self->{CONFIG}}){
961 next if $once_only{$m};
962 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
963 unless exists $Config::Config{$m};
964 $self->{uc $m} ||= $Config::Config{$m};
968 # These should never be needed
969 $self->{LD} ||= 'ld';
970 $self->{OBJ_EXT} ||= '.o';
971 $self->{LIB_EXT} ||= '.a';
973 $self->{MAP_TARGET} ||= "perl";
975 unless ($self->{LIBPERL_A}){
977 $self->{LIBPERL_A} = 'libperl.olb';
979 $self->{LIBPERL_A} = "libperl$self->{LIB_EXT}";
983 # make a few simple checks
984 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
985 (Exporter.pm not found)"
986 unless (-f $self->catfile("$self->{PERL_LIB}","Exporter.pm"));
988 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
989 $self->{VERSION} = "0.10" unless $self->{VERSION};
990 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
992 # Graham Barr and Paul Marquess had some ideas how to ensure
993 # version compatibility between the *.pm file and the
994 # corresponding *.xs file. The bottomline was, that we need an
995 # XS_VERSION macro that defaults to VERSION:
996 # $self->{XS_VERSION} ||= $self->{VERSION};
998 # --- Initialize Perl Binary Locations
1000 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1001 # will be working versions of perl 5. miniperl has priority over perl
1002 # for PERL to ensure that $(PERL) is usable while building ./ext/*
1003 my ($component,@defpath);
1004 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1005 push @defpath, $component if defined $component;
1008 $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1009 \@defpath, $ExtUtils::MakeMaker::Verbose ) unless ($self->{PERL});
1010 # don't check, if perl is executable, maybe they
1011 # have decided to supply switches with perl
1013 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1014 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1015 unless ($self->{FULLPERL});
1018 # Ilya's suggestion, will have to go into ExtUtils::MM_OS2 and MM_VMS
1021 my $path_sep = $Is_OS2 ? ";" : $Is_VMS ? "/" : ":";
1022 my $path = $ENV{PATH};
1023 $path =~ s:\\:/:g if $Is_OS2;
1024 my @path = split $path_sep, $path;
1027 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1030 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1031 $self = $ExtUtils::MakeMaker::Parent[-1];
1033 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1034 local(%pm); #the sub in find() has to see this hash
1035 $ignore{'test.pl'} = 1;
1036 $ignore{'makefile.pl'} = 1 if $Is_VMS;
1037 foreach $name ($self->lsdir(".")){
1038 next if ($name =~ /^\./ or $ignore{$name});
1040 $dir{$name} = $name if (-f "$name/Makefile.PL");
1041 } elsif ($name =~ /\.xs$/){
1042 my($c); ($c = $name) =~ s/\.xs$/.c/;
1045 } elsif ($name =~ /\.c$/i){
1047 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1048 } elsif ($name =~ /\.h$/i){
1050 } elsif ($name =~ /\.(p[ml]|pod)$/){
1051 $pm{$name} = $self->catfile('$(INST_LIBDIR)',"$name");
1052 } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
1053 ($pl_files{$name} = $name) =~ s/\.PL$// ;
1057 # Some larger extensions often wish to install a number of *.pm/pl
1058 # files into the library in various locations.
1060 # The attribute PMLIBDIRS holds an array reference which lists
1061 # subdirectories which we should search for library files to
1062 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1063 # recursively search through the named directories (skipping any
1064 # which don't exist or contain Makefile.PL files).
1066 # For each *.pm or *.pl file found $self->libscan() is called with
1067 # the default installation path in $_[1]. The return value of
1068 # libscan defines the actual installation location. The default
1069 # libscan function simply returns the path. The file is skipped
1070 # if libscan returns false.
1072 # The default installation location passed to libscan in $_[1] is:
1074 # ./*.pm => $(INST_LIBDIR)/*.pm
1075 # ./xyz/... => $(INST_LIBDIR)/xyz/...
1076 # ./lib/... => $(INST_LIB)/...
1078 # In this way the 'lib' directory is seen as the root of the actual
1079 # perl library whereas the others are relative to INST_LIBDIR
1080 # (which includes ROOTEXT). This is a subtle distinction but one
1081 # that's important for nested modules.
1083 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1084 unless $self->{PMLIBDIRS};
1086 #only existing directories that aren't in $dir are allowed
1088 # Avoid $_ wherever possible:
1089 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1090 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1092 @{$self->{PMLIBDIRS}} = ();
1093 foreach $pmlibdir (@pmlibdirs) {
1094 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1097 if (@{$self->{PMLIBDIRS}}){
1098 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1099 if ($ExtUtils::MakeMaker::Verbose >= 2);
1100 use File::Find; # try changing to require !
1101 File::Find::find(sub {
1103 if ($_ eq "CVS" || $_ eq "RCS"){
1104 $File::Find::prune = 1;
1108 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1110 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^lib/::);
1111 my($inst) = $self->catdir($prefix,$striplibpath);
1112 local($_) = $inst; # for backwards compatibility
1113 $inst = $self->libscan($inst);
1114 print "libscan($path) => '$inst'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
1115 return unless $inst;
1117 }, @{$self->{PMLIBDIRS}});
1120 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1121 $self->{XS} = \%xs unless $self->{XS};
1122 $self->{PM} = \%pm unless $self->{PM};
1123 $self->{C} = [sort keys %c] unless $self->{C};
1124 my(@o_files) = @{$self->{C}};
1125 $self->{O_FILES} = [grep s/\.c$/$self->{OBJ_EXT}/i, @o_files] ;
1126 $self->{H} = [sort keys %h] unless $self->{H};
1127 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1129 # Set up names of manual pages to generate from pods
1130 if ($self->{MAN1PODS}) {
1131 } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1132 $self->{MAN1PODS} = {};
1134 my %manifypods = ();
1135 if( exists $self->{EXE_FILES} ){
1136 foreach $name (@{$self->{EXE_FILES}}) {
1139 if (open(TESTPOD,"<$name")) {
1141 while ($testpodline = <TESTPOD>) {
1142 if($testpodline =~ /^=head/) {
1149 # If it doesn't exist yet, we assume, it has pods in it
1153 $manifypods{$name} = $self->catdir('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
1158 $self->{MAN1PODS} = \%manifypods;
1160 if ($self->{MAN3PODS}) {
1161 } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1162 $self->{MAN3PODS} = {};
1164 my %manifypods = (); # we collect the keys first, i.e. the files
1165 # we have to convert to pod
1166 foreach $name (keys %{$self->{PM}}) {
1167 if ($name =~ /\.pod$/ ) {
1168 $manifypods{$name} = $self->{PM}{$name};
1169 } elsif ($name =~ /\.p[ml]$/ ) {
1172 open(TESTPOD,"<$name");
1174 while ($testpodline = <TESTPOD>) {
1175 if($testpodline =~ /^=head/) {
1179 #Speculation on the future (K.A., not A.K. :)
1180 #if(/^=don't\S+install/) { $ispod=0; last}
1185 $manifypods{$name} = $self->{PM}{$name};
1190 # Remove "Configure.pm" and similar, if it's not the only pod listed
1191 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1192 foreach $name (keys %manifypods) {
1193 if ($name =~ /(config|install|setup).*\.pm/i) {
1194 delete $manifypods{$name};
1197 my($manpagename) = $name;
1198 unless ($manpagename =~ s!^lib/!!) {
1199 $manpagename = join("/",$self->{ROOTEXT},$manpagename);
1201 $manpagename =~ s/\.p(od|m|l)$//;
1202 # Strip leading slashes
1203 $manpagename =~ s!^/+!!;
1204 # Turn other slashes into colons
1205 # $manpagename =~ s,/+,::,g;
1206 $manpagename = $self->replace_manpage_seperator($manpagename);
1207 $manifypods{$name} = "\$(INST_MAN3DIR)/$manpagename.\$(MAN3EXT)";
1209 $self->{MAN3PODS} = \%manifypods;
1215 my($dir, $regex) = @_;
1217 opendir(DIR, $dir || ".") or return ();
1220 @ls = grep(/$regex/, @ls) if $regex;
1224 sub replace_manpage_seperator {
1225 my($self,$man) = @_;
1231 my($self,$path) = @_;
1232 return '' if $path =~ m:/RCS/: ;
1236 sub init_others { # --- Initialize Other Attributes
1239 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1240 $self = $ExtUtils::MakeMaker::Parent[-1];
1243 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1244 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1245 # undefined. In any case we turn it into an anon array:
1247 # May check $Config{libs} too, thus not empty.
1248 $self->{LIBS}=[''] unless $self->{LIBS};
1250 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq SCALAR;
1251 $self->{LD_RUN_PATH} = "";
1253 foreach $libs ( @{$self->{LIBS}} ){
1254 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1255 my(@libs) = $self->extliblist($libs);
1256 if ($libs[0] or $libs[1] or $libs[2]){
1257 # LD_RUN_PATH now computed by ExtUtils::Liblist
1258 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1263 unless ( $self->{OBJECT} ){
1264 # init_dirscan should have found out, if we have C files
1265 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1267 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1268 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1269 $self->{PERLMAINCC} ||= '$(CC)';
1270 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1272 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1273 # the 'dynamic' section of MM. We don't have this problem with
1274 # 'static', since we either must use it (%Config says we can't
1275 # use dynamic loading) or the caller asked for it explicitly.
1276 if (!$self->{LINKTYPE}) {
1277 $self->{LINKTYPE} = grep(/dynamic/,@{$self->{SKIP} || []})
1279 : ($Config::Config{usedl} ? 'dynamic' : 'static');
1282 # These get overridden for VMS and maybe some other systems
1284 $self->{FIRST_MAKEFILE} ||= "Makefile";
1285 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1286 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1287 $self->{RM_F} = "rm -f";
1288 $self->{RM_RF} = "rm -rf";
1289 $self->{TOUCH} = "touch";
1292 $self->{CHMOD} = "chmod";
1293 $self->{UMASK_NULL} = "umask 0";
1297 my($self, $ver, $names, $dirs, $trace) = @_;
1299 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1300 $self = $ExtUtils::MakeMaker::Parent[-1];
1304 print "Looking for perl $ver by these names:
1310 foreach $dir (@$dirs){
1311 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1312 foreach $name (@$names){
1314 if ($self->file_name_is_absolute($name)) {
1316 } elsif ($name =~ m|/|) { # file_name_contains_path
1317 $abs = $self->catfile(".", $name);
1319 $abs = $self->catfile($dir, $name);
1321 print "Checking $abs\n" if ($trace >= 2);
1322 next unless $self->maybe_command($abs);
1323 print "Executing $abs\n" if ($trace >= 2);
1324 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
1325 print "Using PERL=$abs\n" if $trace;
1330 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1331 0; # false and not empty
1335 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
1336 sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
1337 my($self, $names, $dirs, $trace, $ver) = @_;
1339 foreach $dir (@$dirs){
1340 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1341 foreach $name (@$names){
1343 if ($self->file_name_is_absolute($name)) {
1345 } elsif ($name =~ m|/|) {
1346 $abs = $self->catfile(".", $name); # not absolute
1348 $abs = $self->catfile($dir, $name);
1350 print "Checking $abs for $name\n" if ($trace >= 2);
1351 next unless $tryabs = $self->maybe_command($abs);
1352 print "Substituting $tryabs instead of $abs\n"
1353 if ($trace >= 2 and $tryabs ne $abs);
1356 print "Executing $abs\n" if ($trace >= 2);
1357 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
1358 print "Using PERL=$abs\n" if $trace;
1361 } else { # Do not look for perl
1369 my($self,$file) = @_;
1370 return $file if -x $file && ! -d $file;
1375 my($self,$file) = @_;
1376 return 1 if -r $file && ! -d $file;
1380 # Ilya's suggestion, not yet used
1381 sub file_name_is_absolute {
1382 my($self,$file) = @_;
1386 sub post_initialize {
1389 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1390 $self = $ExtUtils::MakeMaker::Parent[-1];
1395 # --- Constants Sections ---
1400 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1401 $self = $ExtUtils::MakeMaker::Parent[-1];
1404 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
1405 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
1407 foreach $m (@{$self->{CONFIG}}){
1408 next if $once_only{$m};
1409 push @m, "\U$m\E = ".$self->{uc $m}."\n";
1418 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1419 $self = $ExtUtils::MakeMaker::Parent[-1];
1422 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1423 $self = $ExtUtils::MakeMaker::Parent[-1];
1428 NAME = $self->{NAME}
1429 DISTNAME = $self->{DISTNAME}
1430 NAME_SYM = $self->{NAME_SYM}
1431 VERSION = $self->{VERSION}
1432 VERSION_SYM = $self->{VERSION_SYM}
1433 VERSION_MACRO = VERSION
1434 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
1435 # XS_VERSION = $self->{XS_VERSION}
1436 # XS_VERSION_MACRO = XS_VERSION
1437 # XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
1439 # In which directory should we put this extension during 'make'?
1440 # This is typically ./blib.
1441 # (also see INST_LIBDIR and relationship to ROOTEXT)
1442 INST_LIB = $self->{INST_LIB}
1443 INST_ARCHLIB = $self->{INST_ARCHLIB}
1444 INST_EXE = $self->{INST_EXE}
1446 # AFS users will want to set the installation directories for
1447 # the final 'make install' early without setting INST_LIB,
1448 # INST_ARCHLIB, and INST_EXE for the testing phase
1449 INSTALLPRIVLIB = $self->{INSTALLPRIVLIB}
1450 INSTALLARCHLIB = $self->{INSTALLARCHLIB}
1451 INSTALLBIN = $self->{INSTALLBIN}
1453 # Perl library to use when building the extension
1454 PERL_LIB = $self->{PERL_LIB}
1455 PERL_ARCHLIB = $self->{PERL_ARCHLIB}
1456 LIBPERL_A = $self->{LIBPERL_A}
1458 MAKEMAKER = \$(PERL_LIB)/ExtUtils/MakeMaker.pm
1459 MM_VERSION = $ExtUtils::MakeMaker::VERSION
1460 FIRST_MAKEFILE = $self->{FIRST_MAKEFILE}
1461 MAKE_APERL_FILE = $self->{MAKE_APERL_FILE}
1463 PERLMAINCC = $self->{PERLMAINCC}
1467 # Where is the perl source code located?
1468 PERL_SRC = $self->{PERL_SRC}\n" if $self->{PERL_SRC};
1471 # Perl header files (will eventually be under PERL_LIB)
1472 PERL_INC = $self->{PERL_INC}
1474 PERL = $self->{PERL}
1475 FULLPERL = $self->{FULLPERL}
1478 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
1479 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
1480 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
1481 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
1482 FULLEXT = $self->{FULLEXT}
1483 BASEEXT = $self->{BASEEXT}
1484 ROOTEXT = $self->{ROOTEXT}
1485 DLBASE = $self->{DLBASE}
1489 DEFINE = $self->{DEFINE}
1490 OBJECT = $self->{OBJECT}
1491 LDFROM = $self->{LDFROM}
1492 LINKTYPE = $self->{LINKTYPE}
1494 # Handy lists of source code files:
1495 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
1496 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
1497 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
1498 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
1499 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
1500 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
1502 # Man installation stuff:
1503 INST_MAN1DIR = $self->{INST_MAN1DIR}
1504 INSTALLMAN1DIR = $self->{INSTALLMAN1DIR}
1505 MAN1EXT = $self->{MAN1EXT}
1507 INST_MAN3DIR = $self->{INST_MAN3DIR}
1508 INSTALLMAN3DIR = $self->{INSTALLMAN3DIR}
1509 MAN3EXT = $self->{MAN3EXT}
1512 # work around a famous dec-osf make(1) feature(?):
1515 .SUFFIXES: .xs .c .C \$(OBJ_EXT)
1517 # .PRECIOUS: Makefile # seems to be not necessary anymore
1519 .PHONY: all config static dynamic test linkext
1521 # This extension may link to it's own library (see SDBM_File)
1522 MYEXTLIB = $self->{MYEXTLIB}
1524 # Where is the Config information that we are using/depend on
1525 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
1529 # Where to put things:
1530 INST_LIBDIR = $(INST_LIB)$(ROOTEXT)
1531 INST_ARCHLIBDIR = $(INST_ARCHLIB)$(ROOTEXT)
1533 INST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT)
1534 INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
1537 if ($self->has_link_code()) {
1539 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
1540 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
1541 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
1552 $tmp = "$self->{BASEEXT}.def";
1561 $tmp = "\$(PERL_INC)/libperl.lib";
1570 INST_PM = '.join(" \\\n\t", sort values %{$self->{PM}}).'
1576 sub const_loadlibs {
1579 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1580 $self = $ExtUtils::MakeMaker::Parent[-1];
1582 return "" unless $self->needs_linking;
1583 # This description can be deleted after ExtUtils::Liblist is in
1584 # the perl dist with pods
1586 # $self->{NAME} might depend on some other libraries:
1587 # (These comments may need revising:)
1589 # Dependent libraries can be linked in one of three ways:
1591 # 1. (For static extensions) by the ld command when the perl binary
1592 # is linked with the extension library. See EXTRALIBS below.
1594 # 2. (For dynamic extensions) by the ld command when the shared
1595 # object is built/linked. See LDLOADLIBS below.
1597 # 3. (For dynamic extensions) by the DynaLoader when the shared
1598 # object is loaded. See BSLOADLIBS below.
1600 # EXTRALIBS = List of libraries that need to be linked with when
1601 # linking a perl binary which includes this extension
1602 # Only those libraries that actually exist are included.
1603 # These are written to a file and used when linking perl.
1605 # LDLOADLIBS = List of those libraries which can or must be linked into
1606 # the shared library when created using ld. These may be
1607 # static or dynamic libraries.
1608 # LD_RUN_PATH is a colon separated list of the directories
1609 # in LDLOADLIBS. It is passed as an environment variable to
1610 # the process that links the shared library.
1612 # BSLOADLIBS = List of those libraries that are needed but can be
1613 # linked in dynamically at run time on this platform.
1614 # SunOS/Solaris does not need this because ld records
1615 # the information (from LDLOADLIBS) into the object file.
1616 # This list is used to create a .bs (bootstrap) file.
1618 EXTRALIBS = $self->{EXTRALIBS}
1619 LDLOADLIBS = $self->{LDLOADLIBS}
1620 BSLOADLIBS = $self->{BSLOADLIBS}
1621 LD_RUN_PATH= $self->{LD_RUN_PATH}
1626 my($self,$libperl)=@_;
1628 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1629 $self = $ExtUtils::MakeMaker::Parent[-1];
1631 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
1632 return '' unless $self->needs_linking();
1633 $libperl or $libperl = $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
1634 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
1635 # This is implemented in the same manner as extliblist,
1636 # e.g., do both and compare results during the transition period.
1637 my($cc,$ccflags,$optimize,$large,$split, $shflags)
1638 = @Config{qw(cc ccflags optimize large split shellflags)};
1641 $shflags = '' unless $shflags;
1642 my($prog, $uc, $perltype);
1647 DE => '-DDEBUGGING -DEMBED',
1648 M => '-DEMBED -DMULTIPLICITY',
1649 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
1652 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
1655 $uc = ""; # avoid warning
1657 $perltype = $map{$uc} ? $map{$uc} : "";
1665 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
1666 if ($prog = $Config::Config{$name}) {
1667 # Expand hints for this extension via the shell
1668 print STDOUT "Processing $name hint:\n" if $ExtUtils::MakeMaker::Verbose;
1670 ccflags=\"$ccflags\"
1671 optimize=\"$optimize\"
1672 perltype=\"$perltype\"
1673 optdebug=\"$optdebug\"
1678 echo ccflags=\$ccflags
1679 echo optimize=\$optimize
1680 echo perltype=\$perltype
1681 echo optdebug=\$optdebug
1688 if ($line =~ /(.*?)=\s*(.*)\s*$/){
1690 print STDOUT " $1 = $2\n" if $ExtUtils::MakeMaker::Verbose;
1692 print STDOUT "Unrecognised result from hint: '$line'\n";
1695 ( $cc,$ccflags,$perltype,$optdebug,$optimize,$large,$split )=@cflags{
1696 qw( cc ccflags perltype optdebug optimize large split)};
1700 $optimize = $optdebug;
1703 my($new) = "$cc -c \$(INC) $ccflags $optimize $perltype $large $split";
1704 $new =~ s/^\s+//; $new =~ s/\s+/ /g; $new =~ s/\s+$//;
1707 $cccmd =~ s/^\s*\Q$Config::Config{cc}\E\s/\$(CC) /;
1708 $cccmd .= " \$(DEFINE_VERSION) \$(XS_DEFINE_VERSION)";
1709 $self->{CONST_CCCMD} = "CCCMD = $cccmd\n";
1712 # --- Tool Sections ---
1714 sub tool_autosplit {
1715 my($self, %attribs) = @_;
1717 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1718 $self = $ExtUtils::MakeMaker::Parent[-1];
1721 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
1723 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
1724 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
1731 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1732 $self = $ExtUtils::MakeMaker::Parent[-1];
1734 my($xsdir) = "$self->{PERL_LIB}/ExtUtils";
1735 # drop back to old location if xsubpp is not in new location yet
1736 $xsdir = "$self->{PERL_SRC}/ext" unless (-f "$self->{PERL_LIB}/ExtUtils/xsubpp");
1737 my(@tmdeps) = ('$(XSUBPPDIR)/typemap');
1738 if( $self->{TYPEMAPS} ){
1740 foreach $typemap (@{$self->{TYPEMAPS}}){
1741 if( ! -f $typemap ){
1742 warn "Typemap $typemap not found.\n";
1745 push(@tmdeps, $typemap);
1749 push(@tmdeps, "typemap") if -f "typemap";
1750 my(@tmargs) = map("-typemap $_", @tmdeps);
1751 if( exists $self->{XSOPT} ){
1752 unshift( @tmargs, $self->{XSOPT} );
1755 my $xsubpp_version = $self->xsubpp_version("$xsdir/xsubpp");
1757 # What are the correct thresholds for version 1 && 2 Paul?
1758 if ( $xsubpp_version > 1.923 ){
1759 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
1761 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
1762 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
1763 Your version of xsubpp is $xsubpp_version and cannot handle this.
1764 Please upgrade to a more recent version of xsubpp.
1767 $self->{XSPROTOARG} = "";
1773 XSUBPP = \$(XSUBPPDIR)/xsubpp
1774 XSPROTOARG = $self->{XSPROTOARG}
1775 XSUBPPDEPS = @tmdeps
1776 XSUBPPARGS = @tmargs
1782 my($self,$xsubpp) = @_;
1785 # try to figure out the version number of the xsubpp on the system
1787 # first try the -v flag, introduced in 1.921 & 2.000a2
1789 my $command = "$self->{PERL} $xsubpp -v 2>&1";
1790 print "Running: $command\n" if $Verbose;
1791 $version = `$command` ;
1792 warn "Running '$command' exits with status " . ($?>>8) if $?;
1795 return $1 if $version =~ /^xsubpp version (.*)/ ;
1797 # nope, then try something else
1799 my $counter = '000';
1800 my ($file) = 'temp' ;
1801 $counter++ while -e "$file$counter"; # don't overwrite anything
1804 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
1806 MODULE = fred PACKAGE = fred
1815 $command = "$self->{PERL} $xsubpp $file 2>&1";
1816 print "Running: $command\n" if $Verbose;
1817 my $text = `$command` ;
1818 warn "Running '$command' exits with status " . ($?>>8) if $?;
1821 # gets 1.2 -> 1.92 and 2.000a1
1822 return $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
1824 # it is either 1.0 or 1.1
1825 return 1.1 if $text =~ /^Warning: ignored semicolon/ ;
1827 # none of the above, so 1.0
1834 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1835 $self = $ExtUtils::MakeMaker::Parent[-1];
1840 TOUCH = $self->{TOUCH}
1843 RM_F = $self->{RM_F}
1844 RM_RF = $self->{RM_RF}
1845 CHMOD = $self->{CHMOD}
1846 UMASK_NULL = $self->{UMASK_NULL}
1848 # The following is a portable way to say mkdir -p
1849 # To see which directories are created, change the if 0 to if 1
1850 MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
1851 -e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
1852 -e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
1853 -e 'mkdir("@p",0777)||die $$! } } exit 0;'
1858 my($self, %attribs) = @_;
1860 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1861 $self = $ExtUtils::MakeMaker::Parent[-1];
1864 # VERSION should be sanitised before use as a file name
1865 my($name) = $attribs{NAME} || '$(DISTVNAME)';
1866 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
1867 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
1868 my($compress) = $attribs{COMPRESS} || 'compress'; # eg gzip
1869 my($suffix) = $attribs{SUFFIX} || 'Z'; # eg gz
1870 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
1871 my($preop) = $attribs{PREOP} || '@ true'; # eg update MANIFEST
1872 my($postop) = $attribs{POSTOP} || '@ true'; # eg remove the distdir
1873 my($ci) = $attribs{CI} || 'ci -u';
1874 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
1875 my($dist_cp) = $attribs{DIST_CP} || 'best';
1876 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
1879 DISTVNAME = \$(DISTNAME)-\$(VERSION)
1881 TARFLAGS = $tarflags
1882 COMPRESS = $compress
1888 RCS_LABEL = $rcs_label
1890 DIST_DEFAULT = $dist_default
1896 my($self,%attribs) = @_;
1898 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1899 $self = $ExtUtils::MakeMaker::Parent[-1];
1902 while (($key,$val) = each %attribs){
1903 push @m, "$key = $val\n";
1911 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1912 $self = $ExtUtils::MakeMaker::Parent[-1];
1920 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1921 $self = $ExtUtils::MakeMaker::Parent[-1];
1927 foreach $key (qw(INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
1928 INSTALLMAN1DIR INSTALLMAN3DIR LIBPERL_A
1930 push @pasthru, "$key=\"\$($key)\"";
1933 push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
1937 # --- Translation Sections ---
1942 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1943 $self = $ExtUtils::MakeMaker::Parent[-1];
1945 return '' unless $self->needs_linking();
1949 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1952 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
1960 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1961 $self = $ExtUtils::MakeMaker::Parent[-1];
1963 return '' unless $self->needs_linking();
1966 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
1970 sub xs_o { # many makes are too dumb to use xs_c then c_o
1973 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1974 $self = $ExtUtils::MakeMaker::Parent[-1];
1976 return '' unless $self->needs_linking();
1979 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
1980 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1984 # --- Target Sections ---
1989 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1990 $self = $ExtUtils::MakeMaker::Parent[-1];
1993 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1994 $self = $ExtUtils::MakeMaker::Parent[-1];
1998 all :: config $(INST_PM) subdirs linkext manifypods
2000 subdirs :: $(MYEXTLIB)
2004 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
2006 config :: $(INST_ARCHAUTODIR)/.exists Version_check
2008 config :: $(INST_AUTODIR)/.exists
2011 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
2013 if (%{$self->{MAN1PODS}}) {
2015 config :: $(INST_MAN1DIR)/.exists
2018 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
2020 if (%{$self->{MAN3PODS}}) {
2022 config :: $(INST_MAN3DIR)/.exists
2025 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
2029 $(O_FILES): $(H_FILES)
2030 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
2034 perldoc ExtUtils::MakeMaker
2039 @$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2040 -e 'use ExtUtils::MakeMaker qw($$Version &Version_check);' \
2041 -e '&Version_check("$(MM_VERSION)")'
2048 my($self, %attribs) = @_;
2050 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2051 $self = $ExtUtils::MakeMaker::Parent[-1];
2053 # LINKTYPE => static or dynamic or ''
2054 my($linktype) = defined $attribs{LINKTYPE} ?
2055 $attribs{LINKTYPE} : '$(LINKTYPE)';
2057 linkext :: $linktype
2063 my($self,%attribs) = @_;
2065 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2066 $self = $ExtUtils::MakeMaker::Parent[-1];
2069 return '' if ($Config::Config{osname} ne 'aix');
2071 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
2072 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
2076 dynamic :: $self->{BASEEXT}.exp
2078 ") unless $self->{SKIPHASH}{dynamic};
2081 static :: $self->{BASEEXT}.exp
2083 ") unless $self->{SKIPHASH}{static};
2086 $self->{BASEEXT}.exp: Makefile.PL
2087 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::MakeMaker qw(&mksymlists); \\
2088 MM->new()->mksymlists({DL_FUNCS => ',
2089 %$funcs ? neatvalue($funcs) : '""',', DL_VARS => ',
2090 @$vars ? neatvalue($vars) : '""', ", NAME => \"$self->{NAME}\"})'
2096 # --- Dynamic Loading Sections ---
2101 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2102 $self = $ExtUtils::MakeMaker::Parent[-1];
2105 # $(INST_PM) has been moved to the all: target.
2106 # It remains here for awhile to allow for old usage: "make dynamic"
2107 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
2113 my($self, %attribs) = @_;
2115 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2116 $self = $ExtUtils::MakeMaker::Parent[-1];
2118 return '' unless $self->needs_linking();
2120 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
2122 # As Mkbootstrap might not write a file (if none is required)
2123 # we use touch to prevent make continually trying to remake it.
2124 # The DynaLoader only reads a non-empty file.
2125 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".'
2126 @ echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
2127 @ $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
2128 -e \'use ExtUtils::Mkbootstrap;\' \
2129 -e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
2130 @ $(TOUCH) $(BOOTSTRAP)
2132 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2134 $(INST_BOOT): $(BOOTSTRAP)
2135 @ '.$self->{RM_RF}.' $(INST_BOOT)
2136 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
2138 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2143 my($self, %attribs) = @_;
2145 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2146 $self = $ExtUtils::MakeMaker::Parent[-1];
2148 return '' unless $self->needs_linking(); #might be because of a subdir
2152 ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
2154 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
2155 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
2156 my($ldfrom) = '$(LDFROM)';
2157 my($osname) = $Config::Config{osname};
2158 $armaybe = 'ar' if ($osname eq 'dec_osf' and $armaybe eq ':');
2161 # This section creates the dynamically loadable $(INST_DYNAMIC)
2162 # from $(OBJECT) and possibly $(MYEXTLIB).
2163 ARMAYBE = '.$armaybe.'
2164 OTHERLDFLAGS = '.$otherldflags.'
2166 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE)
2168 if ($armaybe ne ':'){
2169 $ldfrom = 'tmp$(LIB_EXT)';
2170 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
2171 push(@m,' $(RANLIB) '."$ldfrom\n");
2173 $ldfrom = "-all $ldfrom -none" if ($osname eq 'dec_osf');
2174 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
2175 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(LDLOADLIBS) $(EXPORT_LIST) $(PERL_ARCHIVE)');
2178 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2181 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2185 # --- Static Loading Sections ---
2190 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2191 $self = $ExtUtils::MakeMaker::Parent[-1];
2194 # $(INST_PM) has been moved to the all: target.
2195 # It remains here for awhile to allow for old usage: "make static"
2196 static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2204 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2205 $self = $ExtUtils::MakeMaker::Parent[-1];
2207 return '' unless $self->needs_linking(); #might be because of a subdir
2211 ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
2215 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2217 # If this extension has it's own library (eg SDBM_File)
2218 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2219 push(@m, " $self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2222 $(AR) cr $@ $(OBJECT) && $(RANLIB) $@
2223 @echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2225 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2228 # Old mechanism - still available:
2230 push(@m, <<'END') if $self->{PERL_SRC};
2231 @ echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2234 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2239 my($self, %attribs) = @_;
2241 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2242 $self = $ExtUtils::MakeMaker::Parent[-1];
2244 # By default .pm files are split into the architecture independent
2245 # library. This is a good thing. If a specific module requires that
2246 # it's .pm files are split into the architecture specific library
2247 # then it should use: installpm => {SPLITLIB=>'$(INST_ARCHLIB)'}
2248 # Note that installperl currently interferes with this (Config.pm)
2249 # User can disable split by saying: installpm => {SPLITLIB=>''}
2250 my($splitlib) = '$(INST_LIB)'; # NOT arch specific by default
2251 $splitlib = $attribs{SPLITLIB} if exists $attribs{SPLITLIB};
2253 push @m, "inst_pm :: \$(INST_PM)\n\n";
2254 foreach $dist (sort keys %{$self->{PM}}){
2255 my($inst) = $self->{PM}->{$dist};
2256 push(@m, "\n# installpm: $dist => $inst, splitlib=$splitlib\n");
2257 push(@m, $self->installpm_x($dist, $inst, $splitlib));
2263 sub installpm_x { # called by installpm per file
2264 my($self, $dist, $inst, $splitlib) = @_;
2266 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2267 $self = $ExtUtils::MakeMaker::Parent[-1];
2269 warn "Warning: Most probably 'make' will have problems processing this file: $inst\n"
2270 if $inst =~ m![:#]!;
2271 my($instdir) = $inst =~ m|(.*)/|;
2274 $inst: $dist $self->{MAKEFILE} $instdir/.exists
2275 ".' @ '.$self->{RM_F}.' $@
2276 $(UMASK_NULL) && '."$self->{CP} $dist".' $@
2277 @ echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2279 push(@m, "\t\@\$(AUTOSPLITFILE) \$@ $splitlib/auto\n")
2280 if ($splitlib and $inst =~ m/\.pm$/);
2282 push @m, $self->dir_target($instdir);
2287 my($self, %attribs) = @_;
2289 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2290 $self = $ExtUtils::MakeMaker::Parent[-1];
2292 return "\nmanifypods :\n" unless %{$self->{MAN3PODS}};
2295 if (defined $self->{PERL_SRC}) {
2296 $pod2man_exe = "$self->{PERL_SRC}/pod/pod2man";
2298 $pod2man_exe = "$Config{bin}/pod2man";
2300 unless ($self->perl_script($pod2man_exe)) {
2301 # No pod2man but some MAN3PODS to be installed
2304 Warning: I could not locate your pod2man program. Please make sure,
2305 your pod2man program is in your PATH before you execute 'make'
2308 $pod2man_exe = "-S pod2man";
2312 qq[POD2MAN_EXE = $pod2man_exe\n],
2313 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2314 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2315 -e 'print "Installing $$m{$$_}\n";' \\
2316 -e 'system("$(PERL) $(POD2MAN_EXE) $$_>$$m{$$_}")==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2317 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2319 push @m, "\nmanifypods : ";
2320 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2323 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2324 push @m, "\t\@\$(POD2MAN) \\\n\t";
2325 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2333 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2334 $self = $ExtUtils::MakeMaker::Parent[-1];
2336 return "" unless $self->{PL_FILES};
2338 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2340 all :: $self->{PL_FILES}->{$plfile}
2342 $self->{PL_FILES}->{$plfile} :: $plfile
2343 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2351 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2352 return "" unless @{$self->{EXE_FILES}};
2353 my(@m, $from, $to, %fromto, @to);
2354 push @m, $self->dir_target(qw[$(INST_EXE)]);
2355 for $from (@{$self->{EXE_FILES}}) {
2356 my($path)= '$(INST_EXE)/' . basename($from);
2357 local($_) = $path; # for backwards compatibility
2358 $to = $self->exescan($path);
2359 print "exescan($from) => '$to'\n" if ($ExtUtils::MakeMaker::Verbose >=2);
2362 @to = values %fromto;
2364 EXE_FILES = @{$self->{EXE_FILES}}
2372 while (($from,$to) = each %fromto) {
2373 my $todir = dirname($to);
2375 $to: $from $self->{MAKEFILE} $todir/.exists
2376 $self->{CP} $from $to
2383 my($self,$path) = @_;
2386 # --- Sub-directory Sections ---
2391 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2392 $self = $ExtUtils::MakeMaker::Parent[-1];
2395 # This method provides a mechanism to automatically deal with
2396 # subdirectories containing further Makefile.PL scripts.
2397 # It calls the subdir_x() method for each subdirectory.
2398 foreach $dir (@{$self->{DIR}}){
2399 push(@m, $self->subdir_x($dir));
2400 #### print "Including $dir subdirectory\n";
2404 # The default clean, realclean and test targets in this Makefile
2405 # have automatically been given entries for each subdir.
2409 push(@m, "\n# none")
2414 sub runsubdirpl{ # Experimental! See subdir_x section
2415 my($self,$subdir) = @_;
2417 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2418 $self = $ExtUtils::MakeMaker::Parent[-1];
2420 chdir($subdir) or die "chdir($subdir): $!";
2422 require "Makefile.PL";
2426 my($self, $subdir) = @_;
2428 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2429 $self = $ExtUtils::MakeMaker::Parent[-1];
2435 \@-cd $subdir && \$(MAKE) all \$(PASTHRU)
2440 # --- Cleanup and Distribution Sections ---
2443 my($self, %attribs) = @_;
2445 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2446 $self = $ExtUtils::MakeMaker::Parent[-1];
2450 # Delete temporary files but do not touch installed files. We don\'t delete
2451 # the Makefile here so a later make realclean still has a makefile to use.
2455 # clean subdirectories first
2456 for $dir (@{$self->{DIR}}) {
2457 push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
2460 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
2461 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2462 push(@otherfiles, qw[./blib Makeaperlfile $(INST_ARCHAUTODIR)/extralibs.all
2463 perlmain.c mon.out core so_locations
2465 *$(OBJ_EXT) *$(LIB_EXT)
2466 perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
2468 push @m, "\t-$self->{RM_RF} @otherfiles\n";
2469 # See realclean and ext/utils/make_ext for usage of Makefile.old
2471 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
2473 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
2478 my($self, %attribs) = @_;
2480 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2481 $self = $ExtUtils::MakeMaker::Parent[-1];
2485 # Delete temporary files (via clean) and also delete installed files
2486 realclean purge :: clean
2488 # realclean subdirectories first (already cleaned)
2489 my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
2490 foreach(@{$self->{DIR}}){
2491 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2492 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2494 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2495 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2496 push(@m, " $self->{RM_F} \$(INST_STATIC) \$(INST_PM)\n");
2497 my(@otherfiles) = ($self->{MAKEFILE},
2498 "$self->{MAKEFILE}.old"); # Makefiles last
2499 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2500 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
2501 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
2508 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2509 $self = $ExtUtils::MakeMaker::Parent[-1];
2513 distclean :: realclean distcheck
2518 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
2524 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
2530 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
2539 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2540 $self = $ExtUtils::MakeMaker::Parent[-1];
2544 dist : $(DIST_DEFAULT)
2546 tardist : $(DISTVNAME).tar.$(SUFFIX)
2548 $(DISTVNAME).tar.$(SUFFIX) : distdir
2550 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
2551 $(RM_RF) $(DISTVNAME)
2552 $(COMPRESS) $(DISTVNAME).tar
2555 uutardist : $(DISTVNAME).tar.$(SUFFIX)
2556 uuencode $(DISTVNAME).tar.$(SUFFIX) \\
2557 $(DISTVNAME).tar.$(SUFFIX) > \\
2558 $(DISTVNAME).tar.$(SUFFIX).uu
2562 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
2563 $(RM_RF) $(DISTVNAME)
2572 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2573 $self = $ExtUtils::MakeMaker::Parent[-1];
2578 $(RM_RF) $(DISTVNAME)
2579 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "/mani/";' \\
2580 -e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
2588 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2589 $self = $ExtUtils::MakeMaker::Parent[-1];
2594 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
2595 cd $(DISTVNAME) && $(MAKE)
2596 cd $(DISTVNAME) && $(MAKE) test
2604 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2605 $self = $ExtUtils::MakeMaker::Parent[-1];
2610 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
2611 -e '@all = keys %{ maniread() };' \\
2612 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
2613 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
2619 my($self, %attribs) = @_;
2621 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2622 $self = $ExtUtils::MakeMaker::Parent[-1];
2627 @ echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2628 @ $(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \\
2629 -e "use ExtUtils::MakeMaker; MY->new({})->writedoc('Module', '$(NAME)', \\
2630 'LINKTYPE=$(LINKTYPE)', 'VERSION=$(VERSION)', \\
2631 'EXE_FILES=$(EXE_FILES)')" >> $(INSTALLARCHLIB)/perllocal.pod
2635 install :: pure_install doc_install
2639 # install subdirectories first
2640 push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) install\n",
2643 push(@m, "\t\@\$(PERL) \"-I\$(PERL_ARCHLIB)\" \"-I\$(PERL_LIB)\" -e 'require File::Path;' \\
2644 -e '\$\$message = q[ You do not have permissions to install into];' \\
2645 -e 'File::Path::mkpath(\@ARGV);' \\
2646 -e 'foreach (\@ARGV){ die qq{ \$\$message \$\$_\\n} unless -w \$\$_}' \\
2647 \$(INSTALLPRIVLIB) \$(INSTALLARCHLIB)
2648 \$(MAKE) INST_LIB=\$(INSTALLPRIVLIB) INST_ARCHLIB=\$(INSTALLARCHLIB) INST_EXE=\$(INSTALLBIN) INST_MAN1DIR=\$(INSTALLMAN1DIR) INST_MAN3DIR=\$(INSTALLMAN3DIR) all
2651 # .packlist is not supported in this MakeMaker, because it needs a serious fix. -i.bak
2652 # is not allowed in an environment, with afs, we have to read here, write there, and I
2653 # don't have time to fix it today -> TODO
2654 # The following line was executed with MMs up to 5.10:
2655 # \@\$(PERL) -i.bak -lne 'print unless \$\$seen{ \$\$_ }++' \$(PERL_ARCHLIB)/auto/\$(FULLEXT)/.packlist
2659 #### UNINSTALL IS STILL EXPERIMENTAL ####
2663 push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) uninstall\n",
2665 push @m, "\t".'$(RM_RF) `cat $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist`
2675 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2676 $self = $ExtUtils::MakeMaker::Parent[-1];
2678 '# Phony target to force checking subdirectories.
2687 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2688 $self = $ExtUtils::MakeMaker::Parent[-1];
2692 PERL_HDRS = $(PERL_INC)/EXTERN.h $(PERL_INC)/INTERN.h \
2693 $(PERL_INC)/XSUB.h $(PERL_INC)/av.h $(PERL_INC)/cop.h \
2694 $(PERL_INC)/cv.h $(PERL_INC)/dosish.h $(PERL_INC)/embed.h \
2695 $(PERL_INC)/form.h $(PERL_INC)/gv.h $(PERL_INC)/handy.h \
2696 $(PERL_INC)/hv.h $(PERL_INC)/keywords.h $(PERL_INC)/mg.h \
2697 $(PERL_INC)/op.h $(PERL_INC)/opcode.h $(PERL_INC)/patchlevel.h \
2698 $(PERL_INC)/perl.h $(PERL_INC)/perly.h $(PERL_INC)/pp.h \
2699 $(PERL_INC)/proto.h $(PERL_INC)/regcomp.h $(PERL_INC)/regexp.h \
2700 $(PERL_INC)/scope.h $(PERL_INC)/sv.h $(PERL_INC)/unixish.h \
2701 $(PERL_INC)/util.h $(PERL_INC)/config.h
2706 $(OBJECT) : $(PERL_HDRS)
2707 ' if $self->{OBJECT};
2710 # Check for unpropogated config.sh changes. Should never happen.
2711 # We do NOT just update config.h because that is not sufficient.
2712 # An out of date config.h is not fatal but complains loudly!
2713 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2714 -@echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2716 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2717 @echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2718 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2719 ') if $self->{PERL_SRC};
2721 push(@m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n")
2729 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2730 $self = $ExtUtils::MakeMaker::Parent[-1];
2733 # We do not know what target was originally specified so we
2734 # must force a manual rerun to be sure. But as it should only
2735 # happen very rarely it is not a significant problem.
2737 $(OBJECT) : $(FIRST_MAKEFILE)
2738 ' if $self->{OBJECT};
2741 # We take a very conservative approach here, but it\'s worth it.
2742 # We move Makefile to Makefile.old here to avoid gnu make looping.
2743 '.$self->{MAKEFILE}.' : Makefile.PL $(CONFIGDEP)
2744 @echo "Makefile out-of-date with respect to $?"
2745 @echo "Cleaning current config before rebuilding Makefile..."
2746 -@mv '."$self->{MAKEFILE} $self->{MAKEFILE}.old".'
2747 -$(MAKE) -f '.$self->{MAKEFILE}.'.old clean >/dev/null 2>&1 || true
2748 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL '."@ARGV".'
2749 @echo ">>> Your Makefile has been rebuilt. <<<"
2750 @echo ">>> Please rerun the make command. <<<"; false
2757 my($self, %attribs) = @_;
2759 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2760 $self = $ExtUtils::MakeMaker::Parent[-1];
2764 my(%searchdirs)=($self->{PERL_ARCHLIB} => 1, $self->{INST_ARCHLIB} => 1);
2765 my(@searchdirs)=keys %searchdirs;
2767 # And as it's not yet built, we add the current extension
2768 # but only if it has some C code (or XS code, which implies C code)
2769 if (@{$self->{C}}) {
2770 @static="$self->{INST_ARCHLIB}/auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}";
2773 # Either we determine now, which libraries we will produce in the
2774 # subdirectories or we do it at runtime of the make.
2776 # We could ask all subdir objects, but I cannot imagine, why it
2777 # would be necessary.
2779 # Instead we determine all libraries for the new perl at
2781 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2783 $self->makeaperl(MAKE => $self->{MAKEFILE},
2784 DIRS => \@searchdirs,
2787 TARGET => $self->{MAP_TARGET},
2789 LIBPERL => $self->{LIBPERL_A}
2793 # --- Test and Installation Sections ---
2796 my($self, %attribs) = @_;
2798 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2799 $self = $ExtUtils::MakeMaker::Parent[-1];
2801 my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2805 TEST_TYPE=test_\$(LINKTYPE)
2807 test :: \$(TEST_TYPE)
2809 push(@m, map("\t\@cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2811 push(@m, "\t\@echo 'No tests defined for \$(NAME) extension.'\n")
2812 unless $tests or -f "test.pl" or @{$self->{DIR}};
2815 push(@m, "test_dynamic :: all\n");
2816 push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2817 push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2820 # Occasionally we may face this degenerated target:
2821 push @m, "test_ : test_dynamic\n\n";
2823 if ($self->needs_linking()) {
2824 push(@m, "test_static :: all \$(MAP_TARGET)\n");
2825 push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2826 push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2829 push @m, "test_static :: test_dynamic\n";
2834 sub test_via_harness {
2835 my($self, $perl, $tests) = @_;
2837 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2838 $self = $ExtUtils::MakeMaker::Parent[-1];
2840 "\tPERL_DL_NONLAZY=1 $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";
2843 sub test_via_script {
2844 my($self, $perl, $script) = @_;
2846 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2847 $self = $ExtUtils::MakeMaker::Parent[-1];
2849 "\tPERL_DL_NONLAZY=1 $perl".' -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) test.pl
2857 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2858 $self = $ExtUtils::MakeMaker::Parent[-1];
2864 my($self, %attribs) = @_;
2866 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2867 $self = $ExtUtils::MakeMaker::Parent[-1];
2869 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2870 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2873 # --- MakeMaker makeaperl section ---
2874 MAP_TARGET = $target
2875 FULLPERL = $self->{FULLPERL}
2877 return join '', @m if $self->{PARENT};
2879 my($dir) = join ":", @{$self->{DIR}};
2881 unless ($self->{MAKEAPERL}) {
2883 $(MAP_TARGET) :: $(MAKE_APERL_FILE)
2884 $(MAKE) -f Makefile.aperl static $@
2886 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2887 @ echo Writing \"Makefile.aperl\" for this $(MAP_TARGET)
2888 @ $(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2889 Makefile.PL DIR=}, $dir, q{ \
2890 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2891 MAKEAPERL=1 NORECURS=1};
2893 push @m, map( " \\\n\t\t$_", @ARGV );
2901 my($cccmd, $linkcmd, $lperl);
2904 $cccmd = $self->const_cccmd($libperl);
2905 $cccmd =~ s/^CCCMD\s*=\s*//;
2906 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2907 $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
2908 $cccmd =~ s/\n/ /g; # yes I've seen "\n", don't ask me where it came from. A.K.
2909 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2911 # The front matter of the linkcommand...
2912 $linkcmd = join ' ', "\$(CC)",
2913 grep($_, @Config{qw(large split ldflags ccdlflags)});
2914 $linkcmd =~ s/\s+/ /g;
2916 # Which *.a files could we make use of...
2918 File::Find::find(sub {
2919 return unless m/\Q$self->{LIB_EXT}\E$/;
2920 return if m/^libperl/;
2921 # don't include the installed version of this extension. I
2922 # leave this line here, although it is not necessary anymore:
2923 # I patched minimod.PL instead, so that Miniperl.pm won't
2924 # enclude duplicates
2926 # Once the patch to minimod.PL is in the distribution, I can
2928 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2929 $static{fastcwd() . "/" . $_}++;
2930 }, grep( -d $_, @{$searchdirs || []}) );
2932 # We trust that what has been handed in as argument, will be buildable
2933 $static = [] unless $static;
2934 @static{@{$static}} = (1) x @{$static};
2936 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2937 for (sort keys %static) {
2938 next unless /\Q$self->{LIB_EXT}\E$/;
2939 $_ = dirname($_) . "/extralibs.ld";
2943 grep(s/^/-I/, @{$perlinc || []});
2945 $target = "perl" unless $target;
2946 $tmp = "." unless $tmp;
2948 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2949 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2950 # extralibs.all are computed correctly
2952 MAP_LINKCMD = $linkcmd
2953 MAP_PERLINC = @{$perlinc || []}
2955 join(" \\\n\t", reverse sort keys %static), "
2957 MAP_PRELIBS = $Config::Config{libs} $Config::Config{cryptlib}
2960 if (defined $libperl) {
2961 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2963 unless ($libperl && -f $lperl) { # Could quite follow your idea her, Ilya
2964 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2965 $libperl ||= "libperl$self->{LIB_EXT}";
2966 $libperl = "$dir/$libperl";
2967 $lperl ||= "libperl$self->{LIB_EXT}";
2968 $lperl = "$dir/$lperl";
2969 print STDOUT "Warning: $libperl not found
2970 If you're going to build a static perl binary, make sure perl is installed
2971 otherwise ignore this warning\n"
2972 unless (-f $lperl || defined($self->{PERL_SRC}));
2976 MAP_LIBPERL = $libperl
2980 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2981 \@ $self->{RM_F} \$\@
2986 foreach $catfile (@$extra){
2987 push @m, "\tcat $catfile >> \$\@\n";
2991 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2992 \$(MAP_LINKCMD) -o \$\@ $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2993 @ echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2994 @ echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2995 @ echo 'To remove the intermediate files say'
2996 @ echo ' make -f $makefilename map_clean'
2998 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
3000 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
3003 $tmp/perlmain.c: $makefilename}, q{
3005 @ $(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
3006 writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
3010 # We write EXTRA outside the perl program to have it eval'd by the shell
3013 @ echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
3014 @ $(FULLPERL) -e 'use ExtUtils::MakeMaker; MY->new->writedoc("Perl binary",' \\
3015 -e '"$(MAP_TARGET)", "MAP_STATIC=$(MAP_STATIC)",' \\
3016 -e '"MAP_EXTRA=@ARGV", "MAP_LIBPERL=$(MAP_LIBPERL)")' \\
3017 -- `cat $(INST_ARCHAUTODIR)/extralibs.all` >> $(INSTALLARCHLIB)/perllocal.pod
3021 inst_perl: pure_inst_perl doc_inst_perl
3023 pure_inst_perl: \$(MAP_TARGET)
3024 $self->{CP} \$(MAP_TARGET) \$(INSTALLBIN)/\$(MAP_TARGET)
3029 $self->{RM_F} $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
3036 my($self,$libs) = @_;
3038 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3039 $self = $ExtUtils::MakeMaker::Parent[-1];
3041 require ExtUtils::Liblist;
3042 ExtUtils::Liblist::ext($libs, $ExtUtils::MakeMaker::Verbose);
3048 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3049 $self = $ExtUtils::MakeMaker::Parent[-1];
3053 # only AIX requires a symbol list at this point
3054 # (so does VMS, but that's handled by the MM_VMS package)
3055 return '' unless $Config::Config{osname} eq 'aix';
3057 $self->init_main(@ARGV) unless defined $self->{BASEEXT};
3058 if (! $self->{DL_FUNCS}) {
3060 ($bootfunc = $self->{NAME}) =~ s/\W/_/g;
3061 $self->{DL_FUNCS} = {$self->{BASEEXT} => ["boot_$bootfunc"]};
3063 rename "$self->{BASEEXT}.exp", "$self->{BASEEXT}.exp_old";
3065 open(EXP,">$self->{BASEEXT}.exp") or die $!;
3066 print EXP join("\n",@{$self->{DL_VARS}}, "\n") if $self->{DL_VARS};
3067 foreach $pkg (keys %{$self->{DL_FUNCS}}) {
3068 (my($prefix) = $pkg) =~ s/\W/_/g;
3070 foreach $func (@{$self->{DL_FUNCS}->{$pkg}}) {
3071 $func = "XS_${prefix}_$func" unless $func =~ /^boot_/;
3072 print EXP "$func\n";
3078 # --- Make-Directories section (internal method) ---
3079 # dir_target(@array) returns a Makefile entry for the file .exists in each
3080 # named directory. Returns nothing, if the entry has already been processed.
3081 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
3082 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
3083 # prerequisite, because there has to be one, something that doesn't change
3087 my($self,@dirs) = @_;
3089 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3090 $self = $ExtUtils::MakeMaker::Parent[-1];
3093 foreach $dir (@dirs) {
3094 next if $self->{DIR_TARGET}{$self}{$dir}++;
3096 $dir/.exists :: \$(PERL)
3098 \@ \$(TOUCH) $dir/.exists
3099 \@-\$(CHMOD) 755 $dir
3105 # --- Output postprocessing section ---
3106 # nicetext is included to make VMS support easier
3107 sub nicetext { # Just return the input - no action needed
3108 my($self,$text) = @_;
3110 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3111 $self = $ExtUtils::MakeMaker::Parent[-1];
3116 sub needs_linking { # Does this module need linking? Looks into
3117 # subdirectory objects (see also has_link_code()
3120 $caller = (caller(0))[3];
3122 ExtUtils::MakeMaker::TieAtt::warndirectuse($caller);
3123 $self = $ExtUtils::MakeMaker::Parent[-1];
3125 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
3126 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
3128 # print Carp::longmess();
3129 # print "EO_DEBUG\n";
3130 if ($self->has_link_code or $self->{MAKEAPERL}){
3131 $self->{NEEDS_LINKING} = 1;
3134 foreach $child (keys %{$self->{CHILDREN}}) {
3135 if ($self->{CHILDREN}->{$child}->needs_linking) {
3136 $self->{NEEDS_LINKING} = 1;
3140 return $self->{NEEDS_LINKING} = 0;
3145 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
3146 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
3147 $self->{HAS_LINK_CODE} = 1;
3150 return $self->{HAS_LINK_CODE} = 0;
3153 # --- perllocal.pod section ---
3155 my($self,$what,$name,@attribs)=@_;
3157 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3158 $self = $ExtUtils::MakeMaker::Parent[-1];
3162 chop($time = ctime(time));
3163 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3164 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3165 print "\n\n=back\n\n";
3168 sub catdir { shift; join('/',@_); }
3169 sub catfile { shift; join('/',@_); }
3171 package ExtUtils::MM_OS2;
3175 #use File::Basename;
3178 Exporter::import('ExtUtils::MakeMaker',
3182 my($self,%attribs) = @_;
3184 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
3185 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
3187 (my $boot = $self->{NAME}) =~ s/:/_/g;
3189 if (not $self->{SKIPHASH}{'dynamic'}) {
3191 $self->{BASEEXT}.def: Makefile.PL"
3193 echo "LIBRARY ' . "'$self->{DLBASE}'" . ' INITINSTANCE TERMINSTANCE" > $@ ; \\
3194 echo "CODE LOADONCALL" >> $@ ; \\
3195 echo "DATA LOADONCALL NONSHARED MULTIPLE" >> $@ ; \\
3196 echo "EXPORTS" >> $@ ; \\
3197 echo " ' . "boot_$boot" . '" >> $@');
3198 foreach $sym (keys %$funcs, @$vars) {
3200 echo \" $sym\" >> \$@");
3208 sub replace_manpage_seperator {
3209 my($self,$man) = @_;
3215 my($self,$file) = @_;
3216 return $file if -x $file && ! -d _;
3217 return "$file.exe" if -x "$file.exe" && ! -d _;
3218 return "$file.cmd" if -x "$file.cmd" && ! -d _;
3222 sub file_name_is_absolute {
3223 my($self,$file) = @_;
3224 $file =~ m{^([a-z]:)?[\\/]}i ;
3228 # the following keeps AutoSplit happy
3229 package ExtUtils::MakeMaker;
3236 ExtUtils::MakeMaker - create an extension Makefile
3240 C<use ExtUtils::MakeMaker;>
3242 C<WriteMakefile( ATTRIBUTE =E<gt> VALUE [, ...] );>
3246 C<MM-E<gt>new(\%att)-E<gt>flush;>
3250 This utility is designed to write a Makefile for an extension module
3251 from a Makefile.PL. It is based on the Makefile.SH model provided by
3252 Andy Dougherty and the perl5-porters.
3254 It splits the task of generating the Makefile into several subroutines
3255 that can be individually overridden. Each subroutine returns the text
3256 it wishes to have written to the Makefile.
3258 =head2 Hintsfile support
3260 MakeMaker.pm uses the architecture specific information from
3261 Config.pm. In addition it evaluates architecture specific hints files
3262 in a C<hints/> directory. The hints files are expected to be named
3263 like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
3264 name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
3265 MakeMaker within the WriteMakefile() subroutine, and can be used to
3266 execute commands as well as to include special variables. The rules
3267 which hintsfile is chosen are the same as in Configure.
3269 The hintsfile is eval()ed immediately after the arguments given to
3270 WriteMakefile are stuffed into a hash reference $self but before this
3271 reference becomes blessed. So if you want to do the equivalent to
3272 override or create an attribute you would say something like
3274 $self->{LIBS} = ['-ldbm -lucb -lc'];
3276 =head2 What's new in version 5 of MakeMaker
3278 MakeMaker 5 is pure object oriented. This allows us to write an
3279 unlimited number of Makefiles with a single perl process. 'perl
3280 Makefile.PL' with MakeMaker 5 goes through all subdirectories
3281 immediately and evaluates any Makefile.PL found in the next level
3282 subdirectories. The benefit of this approach comes in useful for both
3283 single and multi directories extensions.
3285 Multi directory extensions have an immediately visible speed
3286 advantage, because there's no startup penalty for any single
3287 subdirectory Makefile.
3289 Single directory packages benefit from the much improved
3290 needs_linking() method. As the main Makefile knows everything about
3291 the subdirectories, a needs_linking() method can now query all
3292 subdirectories if there is any linking involved down in the tree. The
3293 speedup for PM-only Makefiles seems to be around 1 second on my
3296 =head2 Incompatibilities between MakeMaker 5.00 and 4.23
3298 There are no incompatibilities in the short term, as all changes are
3299 accompanied by short-term workarounds that guarantee full backwards
3302 You are likely to face a few warnings that expose deprecations which
3303 will result in incompatibilities in the long run:
3305 You should not use %att directly anymore. Instead any subroutine you
3306 override in the MY package will be called by the object method, so you
3307 can access all object attributes directly via the object in $_[0].
3309 You should not call the class methos MM->something anymore. Instead
3310 you should call the superclass. Something like
3314 $self->MM::constants();
3317 Especially the libscan() and exescan() methods should be altered
3318 towards OO programming, that means do not expect that $_ to contain
3319 the path but rather $_[1].
3321 You should program with more care. Watch out for any MakeMaker
3322 variables. Do not try to alter them, somebody else might depend on
3323 them. E.g. do not overwrite the ExtUtils::MakeMaker::VERSION variable
3324 (this happens if you import it and then set it to the version number
3325 of your package), do not expect that the INST_LIB variable will be
3326 ./blib (do not 'unshift @INC, "./blib" and do not use
3327 "blib/FindBin.pm"). Do not croak in your Makefile.PL, let it fail with
3330 Try to build several extensions simultanously to debug your
3331 Makefile.PL. You can unpack a bunch of distributed packages, so your
3332 directory looks like
3334 Alias-1.00/ Net-FTP-1.01a/ Set-Scalar-0.001/
3335 ExtUtils-Peek-0.4/ Net-Ping-1.00/ SetDualVar-1.0/
3336 Filter-1.06/ NetTools-1.01a/ Storable-0.1/
3337 GD-1.00/ Religion-1.04/ Sys-Domain-1.05/
3338 MailTools-1.03/ SNMP-1.5b/ Term-ReadLine-0.7/
3340 and write a dummy Makefile.PL that contains nothing but
3342 use ExtUtils::MakeMaker;
3345 That's actually fun to watch :)
3347 Final suggestion: Try to delete all of your MY:: subroutines and
3348 watch, if you really still need them. MakeMaker might already do what
3349 you want without them. That's all about it.
3352 =head2 Default Makefile Behaviour
3354 The automatically generated Makefile enables the user of the extension
3357 perl Makefile.PL # optionally "perl Makefile.PL verbose"
3359 make test # optionally set TEST_VERBOSE=1
3360 make install # See below
3362 The Makefile to be produced may be altered by adding arguments of the
3363 form C<KEY=VALUE>. If the user wants to work with a different perl
3364 than the default, this can be achieved with
3366 perl Makefile.PL PERL=/tmp/myperl5
3368 Other interesting targets in the generated Makefile are
3370 make config # to check if the Makefile is up-to-date
3371 make clean # delete local temp files (Makefile gets renamed)
3372 make realclean # delete derived files (including ./blib)
3373 make dist # see below the Distribution Support section
3375 =head2 Special case make install
3377 make alone puts all relevant files into directories that are named by
3378 the macros INST_LIB, INST_ARCHLIB, INST_EXE, INST_MAN1DIR, and
3379 INST_MAN3DIR. All these default to ./blib or something below blib if
3380 you are I<not> building below the perl source directory. If you I<are>
3381 building below the perl source, INST_LIB and INST_ARCHLIB default to
3382 ../../lib, and INST_EXE is not defined.
3384 The I<install> target of the generated Makefile is a recursive call to
3387 INST_LIB to INSTALLPRIVLIB
3388 INST_ARCHLIB to INSTALLARCHLIB
3389 INST_EXE to INSTALLBIN
3390 INST_MAN1DIR to INSTALLMAN1DIR
3391 INST_MAN3DIR to INSTALLMAN3DIR
3393 The INSTALL... macros in turn default to their %Config
3394 ($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts.
3396 The recommended way to proceed is to set only the INSTALL* macros, not
3397 the INST_* targets. In doing so, you give room to the compilation
3398 process without affecting important directories. Usually a make
3399 test will succeed after the make, and a make install can finish
3402 MakeMaker gives you much more freedom than needed to configure
3403 internal variables and get different results. It is worth to mention,
3404 that make(1) also lets you configure most of the variables that are
3405 used in the Makefile. But in the majority of situations this will not
3406 be necessary, and should only be done, if the author of a package
3409 The usual relationship between INSTALLPRIVLIB and INSTALLARCHLIB is
3410 that the latter is a subdirectory of the former with the name
3411 C<$Config{archname}>, MakeMaker supports the user who sets
3412 INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not, then
3413 MakeMaker defaults the latter to be INSTALLPRIVLIB/ARCHNAME if that
3414 directory exists, otherwise it defaults to INSTALLPRIVLIB.
3417 =head2 PREFIX attribute
3419 The PREFIX attribute can be used to set the INSTALL* attributes
3420 (except INSTALLMAN1DIR) in one go. The quickest way to install a
3421 module in a non-standard place
3423 perl Makefile.PL PREFIX=~
3427 perl Makefile.PL INSTALLPRIVLIB=~/perl5/lib INSTALLBIN=~/bin \
3428 INSTALLMAN3DIR=~/perl5/man/man3
3430 Note, that the tilde expansion is done by MakeMaker, not by perl by
3431 default, nor by make.
3433 It is important to know, that the INSTALL* macros should be absolute
3434 paths, never relativ ones. Packages with multiple Makefile.PLs in
3435 different directories get the contents of the INSTALL* macros
3436 propagated verbatim. (The INST_* macros will be corrected, if they are
3437 relativ paths, but not the INSTALL* macros.)
3439 If the user has superuser privileges, and is not working on AFS
3440 (Andrew File System) or relatives, then the defaults for
3441 INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLBIN, etc. will be appropriate,
3442 and this incantation will be the best:
3444 perl Makefile.PL; make; make test
3447 make install per default writes some documentation of what has been
3448 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This is
3449 an experimental feature. It can be bypassed by calling make
3454 will have to specify the installation directories as these most
3455 probably have changed since perl itself has been installed. They will
3456 have to do this by calling
3458 perl Makefile.PL INSTALLPRIVLIB=/afs/here/today \
3459 INSTALLBIN=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
3462 In nested extensions with many subdirectories, the INSTALL* arguments
3463 will get propagated to the subdirectories. Be careful to repeat this
3464 procedure every time you recompile an extension, unless you are sure
3465 the AFS istallation directories are still valid.
3469 =head2 Static Linking of a new Perl Binary
3471 An extension that is built with the above steps is ready to use on
3472 systems supporting dynamic loading. On systems that do not support
3473 dynamic loading, any newly created extension has to be linked together
3474 with the available resources. MakeMaker supports the linking process
3475 by creating appropriate targets in the Makefile whenever an extension
3476 is built. You can invoke the corresponding section of the makefile with
3480 That produces a new perl binary in the current directory with all
3481 extensions linked in that can be found in INST_ARCHLIB (which usually
3482 is C<./blib>) and PERL_ARCHLIB. To do that, MakeMaker writes a new
3483 Makefile, on UNIX, this is called Makefile.aperl (may be system
3484 dependent). If you want to force the creation of a new perl, it is
3485 recommended, that you delete this Makefile.aperl, so INST_ARCHLIB and
3486 PERL_ARCHLIB are searched-through for linkable libraries again.
3488 The binary can be installed into the directory where perl normally
3489 resides on your machine with
3493 To produce a perl binary with a different name than C<perl>, either say
3495 perl Makefile.PL MAP_TARGET=myperl
3502 make myperl MAP_TARGET=myperl
3503 make inst_perl MAP_TARGET=myperl
3505 In any case you will be prompted with the correct invocation of the
3506 C<inst_perl> target that installs the new binary into INSTALLBIN.
3508 Note, that there is a C<makeaperl> scipt in the perl distribution,
3509 that supports the linking of a new perl binary in a similar fashion,
3510 but with more options.
3512 make inst_perl per default writes some documentation of what has been
3513 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This
3514 can be bypassed by calling make pure_inst_perl.
3516 Warning: the inst_perl: target is rather mighty and will probably
3517 overwrite your existing perl binary. Use with care!
3519 Sometimes you might want to build a statically linked perl although
3520 your system supports dynamic loading. In this case you may explicitly
3521 set the linktype with the invocation of the Makefile.PL or make:
3523 perl Makefile.PL LINKTYPE=static # recommended
3527 make LINKTYPE=static # works on most systems
3529 =head2 Determination of Perl Library and Installation Locations
3531 MakeMaker needs to know, or to guess, where certain things are
3532 located. Especially INST_LIB and INST_ARCHLIB (where to install files
3533 into), PERL_LIB and PERL_ARCHLIB (where to read existing modules
3534 from), and PERL_INC (header files and C<libperl*.*>).
3536 Extensions may be built either using the contents of the perl source
3537 directory tree or from an installed copy of the perl library. The
3538 recommended way is to build extensions after you have run 'make
3539 install' on perl itself. Do that in a directory that is not below the
3540 perl source tree. The support for extensions below the ext directory
3541 of the perl distribution is only good for the standard extensions that
3544 If an extension is being built below the C<ext/> directory of the perl
3545 source then MakeMaker will set PERL_SRC automatically (e.g., C<../..>).
3546 If PERL_SRC is defined then other variables default to the following:
3549 PERL_LIB = PERL_SRC/lib
3550 PERL_ARCHLIB = PERL_SRC/lib
3552 INST_ARCHLIB = PERL_ARCHLIB
3554 If an extension is being built away from the perl source then MakeMaker
3555 will leave PERL_SRC undefined and default to using the installed copy
3556 of the perl library. The other variables default to the following:
3558 PERL_INC = $archlib/CORE
3560 PERL_ARCHLIB = $archlib
3562 INST_ARCHLIB = ./blib/<archname>
3564 If perl has not yet been installed then PERL_SRC can be defined on the
3565 command line as shown in the previous section.
3567 =head2 Useful Default Makefile Macros
3569 FULLEXT = Pathname for extension directory (eg DBD/Oracle).
3571 BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
3573 ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
3575 INST_LIBDIR = C<$(INST_LIB)$(ROOTEXT)>
3577 INST_AUTODIR = C<$(INST_LIB)/auto/$(FULLEXT)>
3579 INST_ARCHAUTODIR = C<$(INST_ARCHLIB)/auto/$(FULLEXT)>
3581 =head2 Using Attributes (and Parameters)
3583 The following attributes can be specified as arguments to WriteMakefile()
3584 or as NAME=VALUE pairs on the command line:
3588 # The following "=item C" is used by the attrib_help routine
3589 # likewise the "=back" below. So be careful when changing it!
3595 Ref to array of *.c file names. Initialised from a directory scan
3596 and the values portion of the XS attribute hash. This is not
3597 currently used by MakeMaker but may be handy in Makefile.PLs.
3601 Arrayref. E.g. [qw(archname manext)] defines ARCHNAME & MANEXT from
3602 config.sh. MakeMaker will add to CONFIG the following values anyway:
3620 CODE reference. Extension writers are requested to do all their
3621 initializing within that subroutine. The subroutine
3622 should return a hash reference. The hash may contain
3623 further attributes, e.g. {LIBS => ...}, that have to
3624 be determined by some evaluation method.
3628 Something like C<"-DHAVE_UNISTD_H">
3632 Ref to array of subdirectories containing Makefile.PLs e.g. [ 'sdbm'
3637 Your name for distributing the package (by tar file) This defaults to
3642 Hashref of symbol names for routines to be made available as
3643 universal symbols. Each key/value pair consists of the package name
3644 and an array of routine names in that package. Used only under AIX
3645 (export lists) and VMS (linker options) at present. The routine
3646 names supplied will be expanded in the same way as XSUB names are
3647 expanded by the XS() macro. Defaults to
3649 {"$(NAME)" => ["boot_$(NAME)" ] }
3653 {"RPC" => [qw( boot_rpcb rpcb_gettime getnetconfigent )],
3654 "NetconfigPtr" => [ 'DESTROY'] }
3658 Array of symbol names for variables to be made available as
3659 universal symbols. Used only under AIX (export lists) and VMS
3660 (linker options) at present. Defaults to []. (e.g. [ qw(
3661 Foo_version Foo_numstreams Foo_tree ) ])
3665 Ref to array of executable files. The files will be copied to the
3666 INST_EXE directory. Make realclean will delete them from there
3669 =item FIRST_MAKEFILE
3671 The name of the Makefile to be produced. Defaults to the contents of
3672 MAKEFILE, but can be overridden. This is used for the second Makefile
3673 that will be produced for the MAP_TARGET.
3677 Perl binary able to run this extension.
3681 Ref to array of *.h file names. Similar to C.
3685 Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
3687 =item INSTALLARCHLIB
3689 Used by 'make install', which sets INST_ARCHLIB to this value.
3693 Used by 'make install' which sets INST_EXE to this value.
3695 =item INSTALLMAN1DIR
3697 This directory gets the man pages at 'make install' time. Defaults to
3698 $Config{installman1dir}.
3700 =item INSTALLMAN3DIR
3702 This directory gets the man pages at 'make install' time. Defaults to
3703 $Config{installman3dir}.
3705 =item INSTALLPRIVLIB
3707 Used by 'make install', which sets INST_LIB to this value.
3711 Same as INST_LIB for architecture dependent files.
3715 Directory, where executable scripts should be installed during
3716 'make'. Defaults to "./blib/ARCHNAME", just to have a dummy
3717 location during testing. make install will set
3718 INST_EXE to INSTALLBIN.
3722 Directory where we put library files of this extension while building
3727 Directory to hold the man pages at 'make' time
3731 Directory to hold the man pages at 'make' time
3735 defaults to "$(OBJECT)" and is used in the ld command to specify
3736 what files to link/load from (also see dynamic_lib below for how to
3741 The filename of the perllibrary that will be used together with this
3742 extension. Defaults to libperl.a.
3746 An anonymous array of alternative library
3747 specifications to be searched for (in order) until
3748 at least one library is found. E.g.
3750 'LIBS' => ["-lgdbm", "-ldbm -lfoo", "-L/path -ldbm.nfs"]
3752 Mind, that any element of the array
3753 contains a complete set of arguments for the ld
3754 command. So do not specify
3756 'LIBS' => ["-ltcl", "-ltk", "-lX11"]
3758 See ODBM_File/Makefile.PL for an example, where an array is needed. If
3759 you specify a scalar as in
3761 'LIBS' => "-ltcl -ltk -lX11"
3763 MakeMaker will turn it into an array with one element.
3767 'static' or 'dynamic' (default unless usedl=undef in config.sh) Should
3768 only be used to force static linking (also see
3773 Boolean which tells MakeMaker, that it should include the rules to
3774 make a perl. This is handled automatically as a switch by
3775 MakeMaker. The user normally does not need it.
3779 The name of the Makefile to be produced.
3783 Hashref of pod-containing files. MakeMaker will default this to all
3784 EXE_FILES files that include POD directives. The files listed
3785 here will be converted to man pages and installed as was requested
3790 Hashref of .pm and .pod files. MakeMaker will default this to all
3791 .pod and any .pm files that include POD directives. The files listed
3792 here will be converted to man pages and installed as was requested
3797 If it is intended, that a new perl binary be produced, this variable
3798 may hold a name for that binary. Defaults to perl
3802 If the extension links to a library that it builds set this to the
3803 name of the library (see SDBM_File)
3807 Perl module name for this extension (DBD::Oracle). This will default
3808 to the directory name but should be explicitly defined in the
3813 MakeMaker will figure out, if an extension contains linkable code
3814 anywhere down the directory tree, and will set this variable
3815 accordingly, but you can speed it up a very little bit, if you define
3816 this boolean variable yourself.
3820 Boolean. Experimental attribute to inhibit descending into
3825 List of object files, defaults to '$(BASEEXT)$(OBJ_EXT)', but can be a long
3826 string containing all object files, e.g. "tkpBind.o
3827 tkpButton.o tkpCanvas.o"
3831 Perl binary for tasks that can be done by miniperl
3835 The call to the program that is able to compile perlmain.c. Defaults
3840 Same as above for architecture dependent files
3844 Directory containing the Perl library to use.
3848 Directory containing the Perl source code (use of this should be
3849 avoided, it may be undefined)
3853 Ref to hash of files to be processed as perl programs. MakeMaker
3854 will default to any found *.PL file (except Makefile.PL) being keys
3855 and the basename of the file being the value. E.g.
3857 {'foobar.PL' => 'foobar'}
3859 The *.PL files are expected to produce output to the target files
3864 Hashref of .pm files and *.pl files to be installed. e.g.
3866 {'name_of_file.pm' => '$(INST_LIBDIR)/install_as.pm'}
3868 By default this will include *.pm and *.pl. If a lib directory
3869 exists and is not listed in DIR (above) then any *.pm and *.pl files
3870 it contains will also be included by default. Defining PM in the
3871 Makefile.PL will override PMLIBDIRS.
3875 Ref to array of subdirectories containing library files. Defaults to
3876 [ 'lib', $(BASEEXT) ]. The directories will be scanned and any files
3877 they contain will be installed in the corresponding location in the
3878 library. A libscan() method can be used to alter the behaviour.
3879 Defining PM in the Makefile.PL will override PMLIBDIRS.
3883 Can be used to set the three INSTALL* attributes in one go (except for
3884 INSTALLMAN1DIR). They will have PREFIX as a common directory node and
3885 will branch from that node into lib/, lib/ARCHNAME, and bin/ unless
3886 you override one of them.
3890 Placeholder, not yet implemented. Will eventually be a hashref: Names
3891 of modules that need to be available to run this extension (e.g. Fcntl
3892 for SDBM_File) are the keys of the hash and the desired version is the
3893 value. Needs further evaluation, should probably allow to define
3894 prerequisites among header files, libraries, perl version, etc.
3898 Arryref. E.g. [qw(name1 name2)] skip (do not write) sections of the
3903 Ref to array of typemap file names. Use this when the typemaps are
3904 in some directory other than the current directory or when they are
3905 not named B<typemap>. The last typemap in the list takes
3906 precedence. A typemap in the current directory has highest
3907 precedence, even if it isn't listed in TYPEMAPS. The default system
3908 typemap has lowest precedence.
3912 Your version number for distributing the package. This defaults to
3917 Hashref of .xs files. MakeMaker will default this. e.g.
3919 {'name_of_file.xs' => 'name_of_file.c'}
3921 The .c files will automatically be included in the list of files
3922 deleted by a make clean.
3926 String of options to pass to xsubpp. This might include C<-C++> or
3927 C<-extern>. Do not include typemaps here; the TYPEMAP parameter exists for
3932 May be set to an empty string, which is identical to C<-prototypes>, or
3933 C<-noprototypes>. See the xsubpp documentation for details. MakeMaker
3934 defaults to the empty string.
3938 =head2 Additional lowercase attributes
3940 can be used to pass parameters to the methods which implement that
3941 part of the Makefile. These are not normally required:
3947 {FILES => "*.xyz foo"}
3951 {TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => 'gz',
3952 SHAR => 'shar -m', DIST_CP => 'ln'}
3954 If you specify COMPRESS, then SUFFIX should also be altered, as it is
3955 needed to tell make the target file of the compression. Setting
3956 DIST_CP to ln can be useful, if you need to preserve the timestamps on
3957 your files. DIST_CP can take the values 'cp', which copies the file,
3958 'ln', which links the file, and 'best' which copies symbolic links and
3959 links the rest. Default is 'best'.
3963 {ARMAYBE => 'ar', OTHERLDFLAGS => '...'}
3967 {SPLITLIB => '$(INST_LIB)' (default) or '$(INST_ARCHLIB)'}
3971 {LINKTYPE => 'static', 'dynamic' or ''}
3973 NB: Extensions that have nothing but *.pm files had to say
3977 with Pre-5.0 MakeMakers. Since version 5.00 of MakeMaker such a line
3978 can be deleted safely. MakeMaker recognizes, when there's nothing to
3983 {ANY_MACRO => ANY_VALUE, ...}
3987 {FILES => '$(INST_ARCHAUTODIR)/*.xyz'}
3989 =item tool_autosplit
3997 # bug in pod2html, so leave the =back
3999 # Don't delete this cut, MM depends on it!
4001 =head2 Overriding MakeMaker Methods
4003 If you cannot achieve the desired Makefile behaviour by specifying
4004 attributes you may define private subroutines in the Makefile.PL.
4005 Each subroutines returns the text it wishes to have written to
4006 the Makefile. To override a section of the Makefile you can
4009 sub MY::c_o { "new literal text" }
4011 or you can edit the default by saying something like:
4017 s/old text/new text/;
4021 Both methods above are available for backwards compatibility with
4024 If you still need a different solution, try to develop another
4025 subroutine, that fits your needs and submit the diffs to
4026 F<perl5-porters@nicoh.com> or F<comp.lang.perl.misc> as appropriate.
4028 =head2 Distribution Support
4030 For authors of extensions MakeMaker provides several Makefile
4031 targets. Most of the support comes from the ExtUtils::Manifest module,
4032 where additional documentation can be found.
4036 =item make distcheck
4038 reports which files are below the build directory but not in the
4039 MANIFEST file and vice versa. (See ExtUtils::Manifest::fullcheck() for
4042 =item make skipcheck
4044 reports which files are skipped due to the entries in the
4045 C<MANIFEST.SKIP> file (See ExtUtils::Manifest::skipcheck() for
4048 =item make distclean
4050 does a realclean first and then the distcheck. Note that this is not
4051 needed to build a new distribution as long as you are sure, that the
4052 MANIFEST file is ok.
4056 rewrites the MANIFEST file, adding all remaining files found (See
4057 ExtUtils::Manifest::mkmanifest() for details)
4061 Copies all the files that are in the MANIFEST file to a newly created
4062 directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory
4063 exists, it will be removed first.
4067 Makes a distdir first, and runs a C<perl Makefile.PL>, a make, and
4068 a make test in that directory.
4072 First does a command $(PREOP) which defaults to a null command. Does a
4073 distdir next and runs C<tar> on that directory into a tarfile. Then
4074 deletes the distdir. Finishes with a command $(POSTOP) which defaults
4079 Defaults to $(DIST_DEFAULT) which in turn defaults to tardist.
4081 =item make uutardist
4083 Runs a tardist first and uuencodes the tarfile.
4087 First does a command $(PREOP) which defaults to a null command. Does a
4088 distdir next and runs C<shar> on that directory into a sharfile. Then
4089 deletes the distdir. Finishes with a command $(POSTOP) which defaults
4090 to a null command. Note: For shdist to work properly a C<shar>
4091 program that can handle directories is mandatory.
4095 Does a $(CI) and a $(RCS_LABEL) on all files in the MANIFEST file.
4099 Customization of the dist targets can be done by specifying a hash
4100 reference to the dist attribute of the WriteMakefile call. The
4101 following parameters are recognized:
4104 COMPRESS ('compress')
4107 RCS_LABEL ('rcs -q -Nv$(VERSION_SYM):')
4115 WriteMakefile( 'dist' => { COMPRESS=>"gzip", SUFFIX=>"gz" })
4120 Andy Dougherty F<E<lt>doughera@lafcol.lafayette.eduE<gt>>, Andreas
4121 KE<ouml>nig F<E<lt>A.Koenig@franz.ww.TU-Berlin.DEE<gt>>, Tim Bunce
4122 F<E<lt>Tim.Bunce@ig.co.ukE<gt>>. VMS support by Charles Bailey
4123 F<E<lt>bailey@HMIVAX.HUMGEN.UPENN.EDUE<gt>>. Contact the makemaker
4124 mailing list C<mailto:makemaker@franz.ww.tu-berlin.de>, if you have any
4127 =head1 MODIFICATION HISTORY
4129 For a more complete documentation see the file Changes in the
4130 MakeMaker distribution package.
4134 See the file Todo in the MakeMaker distribution package.