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/11/12 10:05:55 $ by Andreas Koenig
60 # $Id: MakeMaker.pm,v 1.105 1995/11/12 10:05:55 k Exp $
62 $Version = $VERSION = "5.06";
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;
97 #$SIG{__DIE__} = sub { print @_, Carp::longmess(); die; };
98 ####$SIG{__WARN__} = sub { print Carp::longmess(); warn @_; };
99 $SIG{__WARN__} = sub { $_[0] =~ /^Use of uninitialized value/ && return; };
101 # Setup dummy package:
102 # MY exists for overriding methods to be defined within
103 unshift(@MY::ISA, qw(MM));
105 # Dummy package MM inherits actual methods from OS-specific
106 # default packages. We use this intermediate package so
107 # MY::XYZ->func() can call MM->func() and get the proper
108 # default routine without having to know under what OS
111 @MM::ISA = qw[MM_Unix ExtUtils::MakeMaker];
112 unshift @MM::ISA, 'ExtUtils::MM_VMS' if $Is_VMS;
113 unshift @MM::ISA, 'ExtUtils::MM_OS2' if $Is_OS2;
116 @ExtUtils::MakeMaker::MM_Sections_spec = (
117 post_initialize => {},
120 const_loadlibs => {},
121 const_cccmd => {}, # the last but one addition here (CONST_CCCMD)
122 tool_autosplit => {},
127 post_constants => {},
132 top_targets => {}, # currently the last section that adds a key to $self (DIR_TARGET)
156 staticmake => {}, # Sadly this defines more macros
158 postamble => {}, # should always be last the user has hands on
159 selfdocument => {}, # well, he may override it, but he won't do it
161 # looses section ordering
162 %ExtUtils::MakeMaker::MM_Sections = @ExtUtils::MakeMaker::MM_Sections_spec;
164 @ExtUtils::MakeMaker::MM_Sections = grep(!ref, @ExtUtils::MakeMaker::MM_Sections_spec);
166 %ExtUtils::MakeMaker::Recognized_Att_Keys = %ExtUtils::MakeMaker::MM_Sections; # All sections are valid keys.
167 foreach(split(/\n/,attrib_help())){
168 next unless m/^=item\s+(\w+)\s*$/;
169 $ExtUtils::MakeMaker::Recognized_Att_Keys{$1} = $2;
170 print "Attribute '$1' => '$2'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
173 %ExtUtils::MakeMaker::Prepend_dot_dot = qw(
174 INST_LIB 1 INST_ARCHLIB 1 INST_EXE 1 MAP_TARGET 1 INST_MAN1DIR 1 INST_MAN3DIR 1
175 PERL_SRC 1 PERL 1 FULLPERL 1
177 $PACKNAME = "PACK000";
182 The extension you are trying to build apparently is rather old and
183 most probably outdated. We detect that from the fact, that a
184 subroutine "writeMakefile" is called, and this subroutine is not
185 supported anymore since about October 1994.
187 Please contact the author or look into CPAN (details about CPAN can be
188 found in the FAQ and at http:/www.perl.com) for a more recent version
189 of the extension. If you're really desperate, you can try to change
190 the subroutine name from writeMakefile to WriteMakefile and rerun
191 'perl Makefile.PL', but you're most probably left alone, when you do
200 Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
202 MM->new(\%att)->flush;
206 my($class,$self) = @_;
209 print STDOUT "MakeMaker (v$ExtUtils::MakeMaker::VERSION)\n" if $ExtUtils::MakeMaker::Verbose;
210 if (-f "MANIFEST" && ! -f "Makefile"){
214 $self = {} unless (defined $self);
218 my(%initial_att) = %$self; # record initial attributes
220 if (defined $self->{CONFIGURE}) {
221 if (ref $self->{CONFIGURE} eq 'CODE') {
222 $self = { %$self, %{&{$self->{CONFIGURE}}}};
224 croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n";
228 # This is for old Makefiles written pre 5.00, will go away
229 if ( Carp::longmess("") =~ /runsubdirpl/s ){
230 $self->{Correct_relativ_directories}++;
232 $self->{Correct_relativ_directories}=0;
235 my $class = ++$PACKNAME;
238 print "Blessing Object into class [$class]\n" if $ExtUtils::MakeMaker::Verbose;
239 mv_all_methods("MY",$class);
241 ######## tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
242 push @ExtUtils::MakeMaker::Parent, $self;
243 @{"$class\:\:ISA"} = 'MM';
246 if (defined $ExtUtils::MakeMaker::Parent[-2]){
247 $self->{PARENT} = $ExtUtils::MakeMaker::Parent[-2];
249 for $key (keys %ExtUtils::MakeMaker::Prepend_dot_dot) {
250 next unless defined $self->{PARENT}{$key};
251 $self->{$key} = $self->{PARENT}{$key};
252 $self->{$key} = $self->catdir("..",$self->{$key})
253 unless $self->{$key} =~ m!^/!;
255 $self->{PARENT}->{CHILDREN}->{$class} = $self if $self->{PARENT};
257 parse_args($self,@ARGV);
260 $self->{NAME} ||= $self->guess_name;
262 ($self->{NAME_SYM} = $self->{NAME}) =~ s/\W+/_/g;
266 if (! $self->{PERL_SRC} &&
267 $INC{'Config.pm'} ne $self->catdir($Config::Config{archlibexp},'Config.pm')){
268 (my $pthinks = $INC{'Config.pm'}) =~ s!/Config\.pm$!!;
271 Your perl and your Config.pm seem to have different ideas about the architecture
273 Perl thinks: [$pthinks]
274 Config says: [$Config::Config{archname}]
275 This may or may not cause problems. Please check your installation of perl if you
276 have problems building this extension.
280 $self->init_dirscan();
281 $self->init_others();
283 push @{$self->{RESULT}}, <<END;
284 # This Makefile is for the $self->{NAME} extension to perl.
286 # It was generated automatically by MakeMaker version $ExtUtils::MakeMaker::VERSION from the contents
287 # of Makefile.PL. Don't edit this file, edit Makefile.PL instead.
289 # ANY CHANGES MADE HERE WILL BE LOST!
291 # MakeMaker Parameters:
294 foreach $key (sort keys %initial_att){
295 my($v) = neatvalue($initial_att{$key});
296 $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
298 push @{$self->{RESULT}}, "# $key => $v";
301 # turn the SKIP array into a SKIPHASH hash
303 for $skip (@{$self->{SKIP} || []}) {
304 $self->{SKIPHASH}{$skip} = 1;
307 # We run all the subdirectories now. They don't have much to query
308 # from the parent, but the parent has to query them: if they need linking!
310 unless ($self->{NORECURS}) {
311 foreach $dir (@{$self->{DIR}}){
315 open FH, "Makefile.PL";
322 tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
324 foreach $section ( @ExtUtils::MakeMaker::MM_Sections ){
325 print "Processing Makefile '$section' section\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
326 my($skipit) = $self->skipcheck($section);
328 push @{$self->{RESULT}}, "\n# --- MakeMaker $section section $skipit.";
329 } else { # MEMO: b 329 print "$self->{NAME}**$section**\n" and $section eq 'postamble'
330 my(%a) = %{$self->{$section} || {}};
331 push @{$self->{RESULT}}, "\n# --- MakeMaker $section section:";
332 push @{$self->{RESULT}}, "# " . join ", ", %a if $ExtUtils::MakeMaker::Verbose && %a;
333 push @{$self->{RESULT}}, $self->nicetext($self->$section( %a ));
337 push @{$self->{RESULT}}, "\n# End.";
338 ######## untie %::att;
339 pop @ExtUtils::MakeMaker::Parent;
345 eval {require ExtUtils::Manifest};
347 print STDOUT "Warning: you have not installed the ExtUtils::Manifest
348 module -- skipping check of the MANIFEST file\n";
350 print STDOUT "Checking if your kit is complete...\n";
351 $ExtUtils::Manifest::Quiet=$ExtUtils::Manifest::Quiet=1; #avoid warning
352 my(@missed)=ExtUtils::Manifest::manicheck();
354 print STDOUT "Warning: the following files are missing in your kit:\n";
355 print "\t", join "\n\t", @missed;
357 print STDOUT "Please inform the author.\n";
359 print STDOUT "Looks good\n";
365 my($self, @args) = @_;
367 unless (m/(.*?)=(.*)/){
368 help(),exit 1 if m/^help$/;
369 ++$ExtUtils::MakeMaker::Verbose if m/^verb/;
372 my($name, $value) = ($1, $2);
373 if ($value =~ m/^~(\w+)?/){ # tilde with optional username
374 $value =~ s [^~(\w*)]
376 ((getpwnam($1))[7] || "~$1") :
380 # This may go away, in mid 1996
381 if ($self->{Correct_relativ_directories}){
382 $value = $self->catdir("..",$value)
383 if $ExtUtils::MakeMaker::Prepend_dot_dot{$name} && ! $value =~ m!^/!;
385 $self->{$name} = $value;
387 # This may go away, in mid 1996
388 delete $self->{Correct_relativ_directories};
390 # catch old-style 'potential_libs' and inform user how to 'upgrade'
391 if (defined $self->{potential_libs}){
392 my($msg)="'potential_libs' => '$self->{potential_libs}' should be";
393 if ($self->{potential_libs}){
394 print STDOUT "$msg changed to:\n\t'LIBS' => ['$self->{potential_libs}']\n";
396 print STDOUT "$msg deleted.\n";
398 $self->{LIBS} = [$self->{potential_libs}];
399 delete $self->{potential_libs};
401 # catch old-style 'ARMAYBE' and inform user how to 'upgrade'
402 if (defined $self->{ARMAYBE}){
403 my($armaybe) = $self->{ARMAYBE};
404 print STDOUT "ARMAYBE => '$armaybe' should be changed to:\n",
405 "\t'dynamic_lib' => {ARMAYBE => '$armaybe'}\n";
406 my(%dl) = %{$self->{dynamic_lib} || {}};
407 $self->{dynamic_lib} = { %dl, ARMAYBE => $armaybe};
408 delete $self->{ARMAYBE};
410 if (defined $self->{LDTARGET}){
411 print STDOUT "LDTARGET should be changed to LDFROM\n";
412 $self->{LDFROM} = $self->{LDTARGET};
413 delete $self->{LDTARGET};
415 # Turn a DIR argument on the command line into an array
416 if (defined $self->{DIR} && ref \$self->{DIR} eq 'SCALAR') {
417 # So they can choose from the command line, which extensions they want
418 # the grep enables them to have some colons too much in case they
419 # have to build a list with the shell
420 $self->{DIR} = [grep $_, split ":", $self->{DIR}];
423 foreach $mmkey (sort keys %$self){
424 print STDOUT " $mmkey => ", neatvalue($self->{$mmkey}), "\n" if $ExtUtils::MakeMaker::Verbose;
425 print STDOUT "'$mmkey' is not a known MakeMaker parameter name.\n"
426 unless exists $ExtUtils::MakeMaker::Recognized_Att_Keys{$mmkey};
432 # We allow extension-specific hints files.
434 return unless -d "hints";
436 # First we look for the best hintsfile we have
438 my($hint)="$Config::Config{osname}_$Config::Config{osvers}";
443 # Also try without trailing minor version numbers.
445 last if -f "hints/$hint.pl"; # found
447 last unless $hint =~ s/_[^_]*$//; # nothing to cut off
449 return unless -f "hints/$hint.pl"; # really there
451 # execute the hintsfile:
453 open HINTS, "hints/$hint.pl";
454 @goodhints = <HINTS>;
456 print STDOUT "Processing hints file hints/$hint.pl\n";
457 eval join('',@goodhints);
458 print STDOUT $@ if $@;
466 foreach $method (@ExtUtils::MakeMaker::MM_Sections, qw[ dir_target exescan
467 fileparse fileparse_set_fstype init_dirscan init_main init_others
468 installpm_x libscan makeaperl mksymlists needs_linking runsubdirpl
469 subdir_x test_via_harness test_via_script writedoc ]) {
471 # We cannot say "next" here. Nick might call MY->makeaperl
472 # which isn't defined right now
474 # next unless defined &{"${from}::$method"};
476 *{"${to}::$method"} = \&{"${from}::$method"};
477 my $symtab = \%{"${from}::"};
479 # delete would do, if we were sure, nobody ever called
480 # MY->makeaperl directly
482 # delete $symtab->{$method};
484 # If we delete a method, then it will be undefined and cannot
485 # be called. But as long as we have Makefile.PLs that rely on
486 # %MY:: being intact, we have to fill the hole with an
489 eval "package MY; sub $method {local *$method; shift->MY::$method(\@_); }";
493 # We have to clean out %INC also, because the current directory is
494 # changed frequently and Graham Barr prefers to get his version
495 # out of a History.pl file which is "required" so woudn't get
496 # loaded again in another extension requiring a History.pl
499 foreach $inc (keys %INC) {
500 next if $ExtUtils::MakeMaker::NORMAL_INC{$inc};
501 #warn "***$inc*** deleted";
509 BEGIN { my $ISA_TTY = -t STDIN && -t STDOUT }
510 Carp::confess("prompt function called without an argument") unless defined $mess;
511 $def = "" unless defined $def;
512 my $dispdef = "[$def] ";
516 print "$mess $dispdef";
517 chop($ans = <STDIN>);
519 return $ans if defined $ans;
524 return $Attrib_Help if $Attrib_Help;
529 #### local $/ = ""; # bug in 5.001m
530 open POD, $INC{"ExtUtils/MakeMaker.pm"}
531 or die "Open $INC{'ExtUtils/MakeMaker.pm'}: $!";
532 while ($line = <POD>) {
533 $switch ||= $line =~ /^=item NAME\s*$/;
535 last if $line =~ /^=cut/;
539 $Attrib_Help = $help;
542 sub help {print &attrib_help, "\n";}
547 if ($section eq 'dynamic') {
548 print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
549 "in skipped section 'dynamic_bs'\n"
550 if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
551 print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
552 "in skipped section 'dynamic_lib'\n"
553 if $self->{SKIPHASH}{dynamic_lib} && $ExtUtils::MakeMaker::Verbose;
555 if ($section eq 'dynamic_lib') {
556 print STDOUT "Warning (non-fatal): Target '\$(INST_DYNAMIC)' depends on ",
557 "targets in skipped section 'dynamic_bs'\n"
558 if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
560 if ($section eq 'static') {
561 print STDOUT "Warning (non-fatal): Target 'static' depends on targets ",
562 "in skipped section 'static_lib'\n"
563 if $self->{SKIPHASH}{static_lib} && $ExtUtils::MakeMaker::Verbose;
565 return 'skipped' if $self->{SKIPHASH}{$section};
573 print STDOUT "Writing $self->{MAKEFILE} for $self->{NAME}\n";
575 unlink($self->{MAKEFILE}, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : '');
576 open MAKE, ">MakeMaker.tmp" or die "Unable to open MakeMaker.tmp: $!";
578 for $chunk (@{$self->{RESULT}}) {
579 print MAKE "$chunk\n";
583 my($finalname) = $Is_VMS ? "Descrip.MMS" : $self->{MAKEFILE};
584 rename("MakeMaker.tmp", $finalname);
585 chmod 0644, $finalname;
586 system("$Config::Config{eunicefix} $finalname") unless $Config::Config{eunicefix} eq ":";
590 my($checkversion) = @_;
591 die "Your Makefile was built with ExtUtils::MakeMaker v $checkversion.
592 Current Version is $ExtUtils::MakeMaker::VERSION. There have been considerable
593 changes in the meantime.
594 Please rerun 'perl Makefile.PL' to regenerate the Makefile.\n"
595 if $checkversion < $ExtUtils::MakeMaker::Version_OK;
596 printf STDOUT "%s %s %s %s.\n", "Makefile built with ExtUtils::MakeMaker v",
597 $checkversion, "Current Version is", $ExtUtils::MakeMaker::VERSION
598 unless $checkversion == $ExtUtils::MakeMaker::VERSION;
605 tie %att, ExtUtils::MakeMaker::TieAtt, $self;
606 $self->parse_args(@ARGV);
607 $self->mksymlists(@_);
610 # The following mkbootstrap() is only for installations that are calling
611 # the pre-4.1 mkbootstrap() from their old Makefiles. This MakeMaker
612 # writes Makefiles, that use ExtUtils::Mkbootstrap directly.
615 !!! Your Makefile has been built such a long time ago, !!!
616 !!! that is unlikely to work with current MakeMaker. !!!
617 !!! Please rebuild your Makefile !!!
623 return "undef" unless defined $v;
625 return "'$v'" unless $t;
627 my(@m, $elem, @neat);
629 foreach $elem (@$v) {
630 push @neat, "'$elem'";
632 push @m, join ", ", @neat;
636 return "$v" unless $t eq 'HASH';
638 push(@m,"$key=>".neatvalue($val)) while (($key,$val) = each %$v);
639 return "{ ".join(', ',@m)." }";
645 if ($ExtUtils::MakeMaker::Verbose){
646 push @m, "\n# Full list of MakeMaker attribute values:";
647 foreach $key (sort keys %$self){
648 next if $key eq 'RESULT' || $key =~ /^[A-Z][a-z]/;
649 my($v) = neatvalue($self->{$key});
650 $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
652 push @m, "# $key => $v";
660 ## ## ## ## # # # # # # #
661 # # # # # # # # # # ## # # # #
662 # # # # # # # # # # # # ##
663 # # # # # # # # # # ##
664 # # # # # # # ## # # #
665 # # # # ####### ##### # # # # #
674 Exporter::import('ExtUtils::MakeMaker',
677 # These attributes cannot be overridden externally
678 @Other_Att_Keys{qw(EXTRALIBS BSLOADLIBS LDLOADLIBS)} = (1) x 3;
680 if ($Is_VMS = $Config::Config{osname} eq 'VMS') {
681 require VMS::Filespec;
682 import VMS::Filespec 'vmsify';
685 $Is_OS2 = $ExtUtils::MakeMaker::Is_OS2;
687 sub guess_name { # Charles! That's something for MM_VMS
689 my $name = fastcwd();
691 $name =~ s:.*?([^.\]]+)\]:$1: unless ($name =~ s:.*[.\[]ext\.(.*)\]:$1:i);
692 $name =~ s#[.\]]#::#g;
694 $name =~ s:.*/:: unless ($name =~ s:^.*/ext/::);
696 $name =~ s#\-\d+\.\d+$##; # this is new with MM 5.00
704 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
705 $self = $ExtUtils::MakeMaker::Parent[-1];
708 # --- Initialize Module Name and Paths
710 # NAME = The perl module name for this extension (eg DBD::Oracle).
711 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
712 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
713 # ROOTEXT = Directory part of FULLEXT with leading /.
715 $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
717 # Copied from DynaLoader:
719 my(@modparts) = split(/::/,$self->{NAME});
720 my($modfname) = $modparts[-1];
722 # Some systems have restrictions on files names for DLL's etc.
723 # mod2fname returns appropriate file base name (typically truncated)
724 # It may also edit @modparts if required.
725 if (defined &DynaLoader::mod2fname) {
726 $modfname = &DynaLoader::mod2fname(\@modparts);
727 } elsif ($Is_OS2) { # Need manual correction if run with miniperl:-(
728 $modfname = substr($modfname, 0, 7) . '_';
733 $self->{NAME}) =~ s!.*::!! ; #eg. Socket
735 if (defined &DynaLoader::mod2fname or $Is_OS2) {
736 # As of 5.001m, dl_os2 appends '_'
737 $self->{DLBASE} = $modfname; #eg. Socket_
739 $self->{DLBASE} = '$(BASEEXT)';
743 $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
745 $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
748 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
750 # *Real* information: where did we get these two from? ...
751 my $inc_config_dir = dirname($INC{'Config.pm'});
752 my $inc_carp_dir = dirname($INC{'Carp.pm'});
754 # Typically PERL_* and INST_* will be identical but that need
755 # not be the case (e.g., installing into project libraries etc).
757 # Perl Macro: With source No source
758 # PERL_SRC ../.. (undefined)
759 # PERL_LIB PERL_SRC/lib /usr/local/lib/perl5
760 # PERL_ARCHLIB PERL_SRC/lib /usr/local/lib/perl5/sun4-sunos
762 # INST Macro: For standard for any other
764 # INST_LIB PERL_SRC/lib ./blib
765 # INST_ARCHLIB PERL_SRC/lib ./blib/<archname>
767 unless ($self->{PERL_SRC}){
769 foreach $dir (qw(.. ../.. ../../..)){
770 if ( -f "$dir/config.sh"
772 && -f "$dir/lib/Exporter.pm") {
773 $self->{PERL_SRC}=$dir ;
778 if ($self->{PERL_SRC}){
779 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
780 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
781 $self->{PERL_INC} = $self->{PERL_SRC};
782 # catch an situation that has occurred a few times in the past:
783 warn <<EOM unless -s "$self->{PERL_SRC}/cflags";
784 You cannot build extensions below the perl source tree after executing
785 a 'make clean' in the perl source tree.
787 To rebuild extensions distributed with the perl source you should
788 simply Configure (to include those extensions) and then build perl as
789 normal. After installing perl the source tree can be deleted. It is not
790 needed for building extensions.
792 It is recommended that you unpack and build additional extensions away
793 from the perl source tree.
796 # we should also consider $ENV{PERL5LIB} here
797 $self->{PERL_LIB} = $Config::Config{privlibexp} unless $self->{PERL_LIB};
798 $self->{PERL_ARCHLIB} = $Config::Config{archlibexp} unless $self->{PERL_ARCHLIB};
799 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
801 die <<EOM unless (-f ($perl_h = $self->catfile("$self->{PERL_INC}","perl.h")));
802 Error: Unable to locate installed Perl libraries or Perl source code.
804 It is recommended that you install perl in a standard location before
805 building extensions. You can say:
807 $^X Makefile.PL PERL_SRC=/path/to/perl/source/directory
809 if you have not yet installed perl but still want to build this
811 (You get this message, because MakeMaker could not find "$perl_h")
814 # print STDOUT "Using header files found in $self->{PERL_INC}\n"
815 # if $Verbose && $self->needs_linking();
819 # INST_LIB typically pre-set if building an extension after
820 # perl has been built and installed. Setting INST_LIB allows
821 # you to build directly into, say $Config::Config{privlibexp}.
822 unless ($self->{INST_LIB}){
825 ##### XXXXX We have to change this nonsense
827 if (defined $self->{PERL_SRC}) {
828 $self->{INST_LIB} = $self->{PERL_LIB};
830 $self->{INST_LIB} = $self->catdir(".","blib");
833 # Try to work out what INST_ARCHLIB should be if not set:
834 unless ($self->{INST_ARCHLIB}){
836 $self->catdir(".","blib") => $self->catdir(".","blib",$Config::Config{archname}), # our private build lib
837 $self->{PERL_LIB} => $self->{PERL_ARCHLIB},
838 $Config::Config{privlibexp} => $Config::Config{archlibexp},
839 $inc_carp_dir => $inc_config_dir,
841 $self->{INST_ARCHLIB} = $archmap{$self->{INST_LIB}};
842 unless($self->{INST_ARCHLIB}){
843 # Oh dear, we'll have to default it and warn the user
844 my($archname) = $Config::Config{archname};
845 if (-d "$self->{INST_LIB}/$archname"){
846 $self->{INST_ARCHLIB} = $self->catdir("$self->{INST_LIB}","$archname");
847 print STDOUT "Defaulting INST_ARCHLIB to $self->{INST_ARCHLIB}\n";
849 $self->{INST_ARCHLIB} = $self->{INST_LIB};
853 $self->{INST_EXE} ||= $self->catdir('.','blib',$Config::Config{archname});
855 if ($self->{PREFIX}){
856 $self->{INSTALLPRIVLIB} = $self->catdir($self->{PREFIX},"lib","perl5");
857 $self->{INSTALLBIN} = $self->catdir($self->{PREFIX},"bin");
858 $self->{INSTALLMAN3DIR} = $self->catdir($self->{PREFIX},"perl5","man","man3")
859 unless defined $self->{INSTALLMAN3DIR};
862 if( $self->{INSTALLPRIVLIB} && ! $self->{INSTALLARCHLIB} ){
863 my($archname) = $Config::Config{archname};
864 if (-d $self->catdir($self->{INSTALLPRIVLIB},$archname)){
865 $self->{INSTALLARCHLIB} = $self->catdir($self->{INSTALLPRIVLIB},$archname);
866 print STDOUT "Defaulting INSTALLARCHLIB to $self->{INSTALLARCHLIB}\n";
868 $self->{INSTALLARCHLIB} = $self->{INSTALLPRIVLIB};
871 $self->{INSTALLPRIVLIB} ||= $Config::Config{installprivlib};
872 $self->{INSTALLARCHLIB} ||= $Config::Config{installarchlib};
873 $self->{INSTALLBIN} ||= $Config::Config{installbin};
875 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
876 unless defined $self->{INSTALLMAN1DIR};
877 unless (defined $self->{INST_MAN1DIR}){
878 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
879 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
881 $self->{INST_MAN1DIR} = $self->catdir('.','blib','man','man1');
884 $self->{MAN1EXT} ||= $Config::Config{man1ext};
886 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
887 unless defined $self->{INSTALLMAN3DIR};
888 unless (defined $self->{INST_MAN3DIR}){
889 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
890 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
892 $self->{INST_MAN3DIR} = $self->catdir('.','blib','man','man3');
895 $self->{MAN3EXT} ||= $Config::Config{man3ext};
897 $self->{MAP_TARGET} = "perl" unless $self->{MAP_TARGET};
899 $self->{LIB_EXT} = $Config::Config{lib_ext} || ".a";
900 $self->{OBJ_EXT} = $Config::Config{obj_ext} || ".o";
901 $self->{AR} = $Config::Config{ar} || "ar";
903 unless ($self->{LIBPERL_A}){
905 $self->{LIBPERL_A} = 'libperl.olb';
907 $self->{LIBPERL_A} = "libperl$self->{LIB_EXT}";
911 # make a few simple checks
912 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
913 (Exporter.pm not found)"
914 unless (-f $self->catfile("$self->{PERL_LIB}","Exporter.pm"));
916 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
917 $self->{VERSION} = "0.10" unless $self->{VERSION};
918 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
921 # --- Initialize Perl Binary Locations
923 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
924 # will be working versions of perl 5. miniperl has priority over perl
925 # for PERL to ensure that $(PERL) is usable while building ./ext/*
926 my $path_sep = $Is_OS2 ? ";" : $Is_VMS ? "/" : ":";
927 my $path = $ENV{PATH};
928 $path =~ s:\\:/:g if $Is_OS2;
929 my @path = split $path_sep, $path;
930 my ($component,@defpath);
931 foreach $component ($self->{PERL_SRC}, @path, $Config::Config{binexp}) {
932 push @defpath, $component if defined $component;
935 $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
936 \@defpath, $ExtUtils::MakeMaker::Verbose ) unless ($self->{PERL});
937 # don't check, if perl is executable, maybe they
938 # have decided to supply switches with perl
940 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
941 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
942 unless ($self->{FULLPERL});
945 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
948 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
949 $self = $ExtUtils::MakeMaker::Parent[-1];
951 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
952 local(%pm); #the sub in find() has to see this hash
953 $ignore{'test.pl'} = 1;
954 $ignore{'makefile.pl'} = 1 if $Is_VMS;
955 foreach $name ($self->lsdir(".")){
956 next if ($name =~ /^\./ or $ignore{$name});
958 $dir{$name} = $name if (-f "$name/Makefile.PL");
959 } elsif ($name =~ /\.xs$/){
960 my($c); ($c = $name) =~ s/\.xs$/.c/;
963 } elsif ($name =~ /\.c$/){
965 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
966 } elsif ($name =~ /\.h$/){
968 } elsif ($name =~ /\.(p[ml]|pod)$/){
969 $pm{$name} = $self->catfile('$(INST_LIBDIR)',"$name");
970 } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
971 ($pl_files{$name} = $name) =~ s/\.PL$// ;
975 # Some larger extensions often wish to install a number of *.pm/pl
976 # files into the library in various locations.
978 # The attribute PMLIBDIRS holds an array reference which lists
979 # subdirectories which we should search for library files to
980 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].
981 # We recursively search through the named directories (skipping
982 # any which don't exist or contain Makefile.PL files).
984 # For each *.pm or *.pl file found $self->libscan() is called with
985 # the default installation path in $_[1]. The return value of
986 # libscan defines the actual installation location. The default
987 # libscan function simply returns the path. The file is skipped
988 # if libscan returns false.
990 # The default installation location passed to libscan in $_[1] is:
992 # ./*.pm => $(INST_LIBDIR)/*.pm
993 # ./xyz/... => $(INST_LIBDIR)/xyz/...
994 # ./lib/... => $(INST_LIB)/...
996 # In this way the 'lib' directory is seen as the root of the actual
997 # perl library whereas the others are relative to INST_LIBDIR
998 # (which includes ROOTEXT). This is a subtle distinction but one
999 # that's important for nested modules.
1001 $self->{PMLIBDIRS} = [ 'lib', $self->{BASEEXT} ] unless $self->{PMLIBDIRS};
1003 #only existing directories that aren't in $dir are allowed
1005 # Avoid $_ wherever possible:
1006 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1007 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1009 @{$self->{PMLIBDIRS}} = ();
1010 foreach $pmlibdir (@pmlibdirs) {
1011 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1014 if (@{$self->{PMLIBDIRS}}){
1015 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1016 if ($ExtUtils::MakeMaker::Verbose >= 2);
1017 use File::Find; # try changing to require !
1018 File::Find::find(sub {
1020 if ($_ eq "CVS" || $_ eq "RCS"){
1021 $File::Find::prune = 1;
1025 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1027 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^lib/::);
1028 my($inst) = $self->catdir($prefix,$striplibpath);
1029 local($_) = $inst; # for backwards compatibility
1030 $inst = $self->libscan($inst);
1031 print "libscan($path) => '$inst'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
1032 return unless $inst;
1034 }, @{$self->{PMLIBDIRS}});
1037 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1038 $self->{XS} = \%xs unless $self->{XS};
1039 $self->{PM} = \%pm unless $self->{PM};
1040 $self->{C} = [sort keys %c] unless $self->{C};
1041 my(@o_files) = @{$self->{C}};
1042 $self->{O_FILES} = [grep s/\.c$/$self->{OBJ_EXT}/, @o_files] ;
1043 $self->{H} = [sort keys %h] unless $self->{H};
1044 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1046 # Set up names of manual pages to generate from pods
1047 # Configure overrides anything else
1048 if ($self->{MANPODS}) {
1049 } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1050 $self->{MANPODS} = {};
1052 my %manifypods = (); # we collect the keys first, i.e. the files
1053 # we have to convert to pod
1054 foreach $name (keys %{$self->{PM}}) {
1055 if ($name =~ /\.pod$/ ) {
1056 $manifypods{$name} = $self->{PM}{$name};
1057 } elsif ($name =~ /\.p[ml]$/ ) {
1060 open(TESTPOD,"<$name");
1062 while ($testpodline = <TESTPOD>) {
1063 if($testpodline =~ /^=head/) {
1067 #Speculation on the future (K.A., not A.K. :)
1068 #if(/^=don't\S+install/) { $ispod=0; last}
1073 $manifypods{$name} = $self->{PM}{$name};
1078 # Remove "Configure.pm" and similar, if it's not the only pod listed
1079 # To force inclusion, just name it "Configure.pod", or override MANPODS
1080 foreach $name (keys %manifypods) {
1081 if ($name =~ /(config|install|setup).*\.pm/i) {
1082 delete $manifypods{$name};
1085 my($manpagename) = $name;
1086 unless ($manpagename =~ s!^lib/!!) {
1087 $manpagename = join("/",$self->{ROOTEXT},$manpagename);
1089 $manpagename =~ s/\.p(od|m|l)$//;
1090 # Strip leading slashes
1091 $manpagename =~ s!^/+!!;
1092 # Turn other slashes into colons
1093 # $manpagename =~ s,/+,::,g;
1094 $manpagename = $self->replace_manpage_seperator($manpagename);
1095 $manifypods{$name} = "\$(INST_MAN3DIR)/$manpagename.\$(MAN3EXT)";
1097 $self->{MANPODS} = \%manifypods;
1103 my($dir, $regex) = @_;
1105 opendir(DIR, $dir || ".") or return ();
1108 @ls = grep(/$regex/, @ls) if $regex;
1112 sub replace_manpage_seperator {
1113 my($self,$man) = @_;
1119 my($self,$path) = @_;
1120 return '' if $path =~ m:/RCS/: ;
1124 sub init_others { # --- Initialize Other Attributes
1127 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1128 $self = $ExtUtils::MakeMaker::Parent[-1];
1131 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1132 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1133 # undefined. In any case we turn it into an anon array:
1134 $self->{LIBS}=[] unless $self->{LIBS};
1135 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq SCALAR;
1136 $self->{LD_RUN_PATH} = "";
1138 foreach $libs ( @{$self->{LIBS}} ){
1139 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1140 my(@libs) = $self->extliblist($libs);
1141 if ($libs[0] or $libs[1] or $libs[2]){
1142 # LD_RUN_PATH now computed by ExtUtils::Liblist
1143 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1148 print STDOUT "CONFIG must be an array ref\n"
1149 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1150 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1151 push(@{$self->{CONFIG}},
1152 qw(cc libc ldflags lddlflags ccdlflags cccdlflags
1153 ranlib so dlext dlsrc
1155 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
1157 unless ( $self->{OBJECT} ){
1158 # init_dirscan should have found out, if we have C files
1159 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1161 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1162 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1163 $self->{PERLMAINCC} ||= '$(CC)';
1164 $self->{LD} = ($Config::Config{ld} || 'ld') unless $self->{LD};
1165 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1167 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1168 # the 'dynamic' section of MM. We don't have this problem with
1169 # 'static', since we either must use it (%Config says we can't
1170 # use dynamic loading) or the caller asked for it explicitly.
1171 if (!$self->{LINKTYPE}) {
1172 $self->{LINKTYPE} = grep(/dynamic/,@{$self->{SKIP} || []})
1174 : ($Config::Config{usedl} ? 'dynamic' : 'static');
1177 # These get overridden for VMS and maybe some other systems
1179 $self->{FIRST_MAKEFILE} ||= "Makefile";
1180 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1181 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1182 $self->{RM_F} = "rm -f";
1183 $self->{RM_RF} = "rm -rf";
1184 $self->{TOUCH} = "touch";
1187 $self->{CHMOD} = "chmod";
1188 $self->{UMASK_NULL} = "umask 0";
1192 my($self, $ver, $names, $dirs, $trace) = @_;
1194 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1195 $self = $ExtUtils::MakeMaker::Parent[-1];
1199 print "Looking for perl $ver by these names:
1205 foreach $dir (@$dirs){
1206 next unless defined $dir; # $self->{PERL_SRC} may be undefined
1207 foreach $name (@$names){
1209 if ($name =~ m|^/|) {
1211 } elsif ($name =~ m|/|) {
1212 $abs = $self->catfile(".", $name); # not absolute
1214 $abs = $self->catfile($dir, $name);
1216 print "Checking $abs\n" if ($trace >= 2);
1217 next unless $self->maybe_command($abs);
1218 print "Executing $abs\n" if ($trace >= 2);
1219 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
1220 print "Using PERL=$abs\n" if $trace;
1225 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1226 0; # false and not empty
1230 my($self,$file) = @_;
1231 return 1 if -x $file && ! -d $file;
1235 sub post_initialize {
1238 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1239 $self = $ExtUtils::MakeMaker::Parent[-1];
1244 # --- Constants Sections ---
1249 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1250 $self = $ExtUtils::MakeMaker::Parent[-1];
1253 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
1255 foreach $m (@{$self->{CONFIG}}){
1256 next if $once_only{$m};
1257 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1258 unless exists $Config::Config{$m};
1259 push @m, "\U$m\E = $Config::Config{$m}\n";
1268 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1269 $self = $ExtUtils::MakeMaker::Parent[-1];
1272 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1273 $self = $ExtUtils::MakeMaker::Parent[-1];
1278 NAME = $self->{NAME}
1279 DISTNAME = $self->{DISTNAME}
1280 NAME_SYM = $self->{NAME_SYM}
1281 VERSION = $self->{VERSION}
1282 VERSION_SYM = $self->{VERSION_SYM}
1283 VERSION_MACRO = VERSION
1284 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
1286 # In which directory should we put this extension during 'make'?
1287 # This is typically ./blib.
1288 # (also see INST_LIBDIR and relationship to ROOTEXT)
1289 INST_LIB = $self->{INST_LIB}
1290 INST_ARCHLIB = $self->{INST_ARCHLIB}
1291 INST_EXE = $self->{INST_EXE}
1293 # AFS users will want to set the installation directories for
1294 # the final 'make install' early without setting INST_LIB,
1295 # INST_ARCHLIB, and INST_EXE for the testing phase
1296 INSTALLPRIVLIB = $self->{INSTALLPRIVLIB}
1297 INSTALLARCHLIB = $self->{INSTALLARCHLIB}
1298 INSTALLBIN = $self->{INSTALLBIN}
1300 # Perl library to use when building the extension
1301 PERL_LIB = $self->{PERL_LIB}
1302 PERL_ARCHLIB = $self->{PERL_ARCHLIB}
1303 LIBPERL_A = $self->{LIBPERL_A}
1305 MAKEMAKER = \$(PERL_LIB)/ExtUtils/MakeMaker.pm
1306 MM_VERSION = $ExtUtils::MakeMaker::VERSION
1307 FIRST_MAKEFILE = $self->{FIRST_MAKEFILE}
1308 MAKE_APERL_FILE = $self->{MAKE_APERL_FILE}
1310 OBJ_EXT = $self->{OBJ_EXT}
1311 LIB_EXT = $self->{LIB_EXT}
1312 PERLMAINCC = $self->{PERLMAINCC}
1317 # Where is the perl source code located?
1318 PERL_SRC = $self->{PERL_SRC}\n" if $self->{PERL_SRC};
1321 # Perl header files (will eventually be under PERL_LIB)
1322 PERL_INC = $self->{PERL_INC}
1324 PERL = $self->{PERL}
1325 FULLPERL = $self->{FULLPERL}
1328 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
1329 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
1330 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
1331 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
1332 FULLEXT = $self->{FULLEXT}
1333 BASEEXT = $self->{BASEEXT}
1334 ROOTEXT = $self->{ROOTEXT}
1335 DLBASE = $self->{DLBASE}
1339 DEFINE = $self->{DEFINE}
1340 OBJECT = $self->{OBJECT}
1341 LDFROM = $self->{LDFROM}
1342 LINKTYPE = $self->{LINKTYPE}
1344 # Handy lists of source code files:
1345 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
1346 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
1347 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
1348 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
1349 MANPODS = ".join(" \\\n\t", sort keys %{$self->{MANPODS}})."
1351 # Man installation stuff:
1352 INST_MAN1DIR = $self->{INST_MAN1DIR}
1353 INSTALLMAN1DIR = $self->{INSTALLMAN1DIR}
1354 MAN1EXT = $self->{MAN1EXT}
1356 INST_MAN3DIR = $self->{INST_MAN3DIR}
1357 INSTALLMAN3DIR = $self->{INSTALLMAN3DIR}
1358 MAN3EXT = $self->{MAN3EXT}
1361 # work around a famous dec-osf make(1) feature(?):
1364 .SUFFIXES: .xs .c \$(OBJ_EXT)
1366 # .PRECIOUS: Makefile # seems to be not necessary anymore
1368 .PHONY: all config static dynamic test linkext
1370 # This extension may link to it's own library (see SDBM_File)
1371 MYEXTLIB = $self->{MYEXTLIB}
1373 # Where is the Config information that we are using/depend on
1374 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
1378 # Where to put things:
1379 INST_LIBDIR = $(INST_LIB)$(ROOTEXT)
1380 INST_ARCHLIBDIR = $(INST_ARCHLIB)$(ROOTEXT)
1382 INST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT)
1383 INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
1386 if ($self->has_link_code()) {
1388 INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
1389 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
1390 INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
1401 $tmp = "$self->{BASEEXT}.def";
1410 $tmp = "\$(PERL_INC)/libperl.lib";
1419 INST_PM = '.join(" \\\n\t", sort values %{$self->{PM}}).'
1425 sub const_loadlibs {
1428 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1429 $self = $ExtUtils::MakeMaker::Parent[-1];
1431 return "" unless $self->needs_linking;
1433 # $self->{NAME} might depend on some other libraries:
1434 # (These comments may need revising:)
1436 # Dependent libraries can be linked in one of three ways:
1438 # 1. (For static extensions) by the ld command when the perl binary
1439 # is linked with the extension library. See EXTRALIBS below.
1441 # 2. (For dynamic extensions) by the ld command when the shared
1442 # object is built/linked. See LDLOADLIBS below.
1444 # 3. (For dynamic extensions) by the DynaLoader when the shared
1445 # object is loaded. See BSLOADLIBS below.
1447 # EXTRALIBS = List of libraries that need to be linked with when
1448 # linking a perl binary which includes this extension
1449 # Only those libraries that actually exist are included.
1450 # These are written to a file and used when linking perl.
1452 # LDLOADLIBS = List of those libraries which can or must be linked into
1453 # the shared library when created using ld. These may be
1454 # static or dynamic libraries.
1455 # LD_RUN_PATH is a colon separated list of the directories
1456 # in LDLOADLIBS. It is passed as an environment variable to
1457 # the process that links the shared library.
1459 # BSLOADLIBS = List of those libraries that are needed but can be
1460 # linked in dynamically at run time on this platform.
1461 # SunOS/Solaris does not need this because ld records
1462 # the information (from LDLOADLIBS) into the object file.
1463 # This list is used to create a .bs (bootstrap) file.
1465 EXTRALIBS = $self->{EXTRALIBS}
1466 LDLOADLIBS = $self->{LDLOADLIBS}
1467 BSLOADLIBS = $self->{BSLOADLIBS}
1468 LD_RUN_PATH= $self->{LD_RUN_PATH}
1473 my($self,$libperl)=@_;
1475 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1476 $self = $ExtUtils::MakeMaker::Parent[-1];
1478 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
1479 return '' unless $self->needs_linking();
1480 $libperl or $libperl = $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
1481 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
1482 # This is implemented in the same manner as extliblist,
1483 # e.g., do both and compare results during the transition period.
1484 my($cc,$ccflags,$optimize,$large,$split, $shflags)
1485 = @Config{qw(cc ccflags optimize large split shellflags)};
1488 $shflags = '' unless $shflags;
1489 my($prog, $old, $uc, $perltype);
1491 chop($old = `cd $self->{PERL_SRC}; sh $shflags ./cflags $libperl $self->{BASEEXT}.c`)
1492 if $self->{PERL_SRC};
1497 DE => '-DDEBUGGING -DEMBED',
1498 M => '-DEMBED -DMULTIPLICITY',
1499 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
1502 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
1505 $uc = ""; # avoid warning
1507 $perltype = $map{$uc} ? $map{$uc} : "";
1515 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
1516 if ($prog = $Config::Config{$name}) {
1517 # Expand hints for this extension via the shell
1518 print STDOUT "Processing $name hint:\n" if $ExtUtils::MakeMaker::Verbose;
1520 ccflags=\"$ccflags\"
1521 optimize=\"$optimize\"
1522 perltype=\"$perltype\"
1523 optdebug=\"$optdebug\"
1528 echo ccflags=\$ccflags
1529 echo optimize=\$optimize
1530 echo perltype=\$perltype
1531 echo optdebug=\$optdebug
1538 if ($line =~ /(.*?)=\s*(.*)\s*$/){
1540 print STDOUT " $1 = $2\n" if $ExtUtils::MakeMaker::Verbose;
1542 print STDOUT "Unrecognised result from hint: '$line'\n";
1545 ( $cc,$ccflags,$perltype,$optdebug,$optimize,$large,$split )=@cflags{
1546 qw( cc ccflags perltype optdebug optimize large split)};
1550 $optimize = $optdebug;
1553 my($new) = "$cc -c \$(INC) $ccflags $optimize $perltype $large $split";
1554 $new =~ s/^\s+//; $new =~ s/\s+/ /g; $new =~ s/\s+$//;
1555 # if (defined($old)){
1556 # $old =~ s/^\s+//; $old =~ s/\s+/ /g; $old =~ s/\s+$//;
1557 # if ($new ne $old) {
1558 # print STDOUT "Warning (non-fatal): cflags evaluation in ",
1559 # "MakeMaker ($ExtUtils::MakeMaker::VERSION) ",
1560 # "differs from shell output\n",
1561 # " package: $self->{NAME}\n",
1564 # " Using 'old' set.\n",
1565 # Config::myconfig(), "\n";
1568 my($cccmd)=($old) ? $old : $new;
1569 $cccmd =~ s/^\s*\Q$Config::Config{cc}\E\s/\$(CC) /;
1570 $cccmd .= " \$(DEFINE_VERSION)";
1571 $self->{CONST_CCCMD} = "CCCMD = $cccmd\n";
1574 # --- Tool Sections ---
1576 sub tool_autosplit {
1577 my($self, %attribs) = @_;
1579 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1580 $self = $ExtUtils::MakeMaker::Parent[-1];
1583 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
1585 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
1586 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
1593 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1594 $self = $ExtUtils::MakeMaker::Parent[-1];
1596 my($xsdir) = '$(PERL_LIB)/ExtUtils';
1597 # drop back to old location if xsubpp is not in new location yet
1598 $xsdir = '$(PERL_SRC)/ext' unless (-f "$self->{PERL_LIB}/ExtUtils/xsubpp");
1599 my(@tmdeps) = ('$(XSUBPPDIR)/typemap');
1600 if( $self->{TYPEMAPS} ){
1602 foreach $typemap (@{$self->{TYPEMAPS}}){
1603 if( ! -f $typemap ){
1604 warn "Typemap $typemap not found.\n";
1607 push(@tmdeps, $typemap);
1611 push(@tmdeps, "typemap") if -f "typemap";
1612 my(@tmargs) = map("-typemap $_", @tmdeps);
1613 if( exists $self->{XSOPT} ){
1614 unshift( @tmargs, $self->{XSOPT} );
1618 XSUBPP = \$(XSUBPPDIR)/xsubpp
1619 XSUBPPDEPS = @tmdeps
1620 XSUBPPARGS = @tmargs
1627 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1628 $self = $ExtUtils::MakeMaker::Parent[-1];
1633 TOUCH = $self->{TOUCH}
1636 RM_F = $self->{RM_F}
1637 RM_RF = $self->{RM_RF}
1638 CHMOD = $self->{CHMOD}
1639 UMASK_NULL = $self->{UMASK_NULL}
1641 # The following is a portable way to say mkdir -p
1642 # To see which directories are created, change the if 0 to if 1
1643 MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
1644 -e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
1645 -e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
1646 -e 'mkdir("@p",0777)||die $$! } } exit 0;'
1651 my($self, %attribs) = @_;
1653 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1654 $self = $ExtUtils::MakeMaker::Parent[-1];
1657 # VERSION should be sanitised before use as a file name
1658 my($name) = $attribs{NAME} || '$(DISTVNAME)';
1659 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
1660 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
1661 my($compress) = $attribs{COMPRESS} || 'compress'; # eg gzip
1662 my($suffix) = $attribs{SUFFIX} || 'Z'; # eg gz
1663 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
1664 my($preop) = $attribs{PREOP} || '@ true'; # eg update MANIFEST
1665 my($postop) = $attribs{POSTOP} || '@ true'; # eg remove the distdir
1666 my($ci) = $attribs{CI} || 'ci -u';
1667 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
1668 my($dist_cp) = $attribs{DIST_CP} || 'best';
1669 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
1672 DISTVNAME = \$(DISTNAME)-\$(VERSION)
1674 TARFLAGS = $tarflags
1675 COMPRESS = $compress
1681 RCS_LABEL = $rcs_label
1683 DIST_DEFAULT = $dist_default
1689 my($self,%attribs) = @_;
1691 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1692 $self = $ExtUtils::MakeMaker::Parent[-1];
1695 while (($key,$val) = each %attribs){
1696 push @m, "$key = $val\n";
1704 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1705 $self = $ExtUtils::MakeMaker::Parent[-1];
1713 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1714 $self = $ExtUtils::MakeMaker::Parent[-1];
1720 foreach $key (qw(INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
1721 INSTALLMAN1DIR INSTALLMAN3DIR LIBPERL_A
1723 push @pasthru, "$key=\"\$($key)\"";
1726 push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
1730 # --- Translation Sections ---
1735 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1736 $self = $ExtUtils::MakeMaker::Parent[-1];
1738 return '' unless $self->needs_linking();
1742 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1750 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1751 $self = $ExtUtils::MakeMaker::Parent[-1];
1753 return '' unless $self->needs_linking();
1756 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
1760 sub xs_o { # many makes are too dumb to use xs_c then c_o
1763 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1764 $self = $ExtUtils::MakeMaker::Parent[-1];
1766 return '' unless $self->needs_linking();
1769 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
1770 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1774 # --- Target Sections ---
1779 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1780 $self = $ExtUtils::MakeMaker::Parent[-1];
1783 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1784 $self = $ExtUtils::MakeMaker::Parent[-1];
1788 all :: config $(INST_PM) subdirs linkext manifypods
1790 subdirs :: $(MYEXTLIB)
1794 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
1796 config :: $(INST_ARCHAUTODIR)/.exists Version_check
1798 config :: $(INST_AUTODIR)/.exists
1800 config :: $(INST_MAN1DIR)/.exists
1802 config :: $(INST_MAN3DIR)/.exists
1807 #postamble ist einfach leer!
1809 # 5.00 breaks with the incomplete rules set up by Tk-b8. We
1810 # introduce the following dependency for Tk-b8:
1811 if ($self->{NAME} eq 'Tk' && $self->{VERSION} eq 'b8') {
1821 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)
1822 $(INST_MAN1DIR) $(INST_MAN3DIR)]);
1825 $(O_FILES): $(H_FILES)
1826 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
1830 perldoc ExtUtils::MakeMaker
1835 @$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
1836 -e 'use ExtUtils::MakeMaker qw($$Version &Version_check);' \
1837 -e '&Version_check("$(MM_VERSION)")'
1844 my($self, %attribs) = @_;
1846 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1847 $self = $ExtUtils::MakeMaker::Parent[-1];
1849 # LINKTYPE => static or dynamic or ''
1850 my($linktype) = defined $attribs{LINKTYPE} ?
1851 $attribs{LINKTYPE} : '$(LINKTYPE)';
1853 linkext :: $linktype
1859 my($self,%attribs) = @_;
1861 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1862 $self = $ExtUtils::MakeMaker::Parent[-1];
1865 return '' if ($Config::Config{osname} ne 'aix');
1867 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
1868 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
1872 dynamic :: $self->{BASEEXT}.exp
1874 ") unless $self->{SKIPHASH}{dynamic};
1877 static :: $self->{BASEEXT}.exp
1879 ") unless $self->{SKIPHASH}{static};
1882 $self->{BASEEXT}.exp: Makefile.PL
1883 ",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::MakeMaker qw(&mksymlists); \\
1884 MM->mksymlists({DL_FUNCS => ',
1885 %$funcs ? neatvalue($funcs) : '""',', DL_VARS => ',
1886 @$vars ? neatvalue($vars) : '""', ", NAME => \"$self->{NAME}\"})'
1892 # --- Dynamic Loading Sections ---
1897 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1898 $self = $ExtUtils::MakeMaker::Parent[-1];
1901 # $(INST_PM) has been moved to the all: target.
1902 # It remains here for awhile to allow for old usage: "make dynamic"
1903 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
1909 my($self, %attribs) = @_;
1911 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1912 $self = $ExtUtils::MakeMaker::Parent[-1];
1914 return '' unless $self->needs_linking();
1916 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
1918 # As Mkbootstrap might not write a file (if none is required)
1919 # we use touch to prevent make continually trying to remake it.
1920 # The DynaLoader only reads a non-empty file.
1921 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".'
1922 @ echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1923 @ $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
1924 -e \'use ExtUtils::Mkbootstrap;\' \
1925 -e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
1926 @ $(TOUCH) $(BOOTSTRAP)
1928 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
1930 $(INST_BOOT): $(BOOTSTRAP)
1931 @ '.$self->{RM_RF}.' $(INST_BOOT)
1932 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
1934 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
1939 my($self, %attribs) = @_;
1941 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1942 $self = $ExtUtils::MakeMaker::Parent[-1];
1944 return '' unless $self->needs_linking(); #might be because of a subdir
1948 ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
1950 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1951 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1952 my($ldfrom) = '$(LDFROM)';
1953 my($osname) = $Config::Config{osname};
1954 $armaybe = 'ar' if ($osname eq 'dec_osf' and $armaybe eq ':');
1957 # This section creates the dynamically loadable $(INST_DYNAMIC)
1958 # from $(OBJECT) and possibly $(MYEXTLIB).
1959 ARMAYBE = '.$armaybe.'
1960 OTHERLDFLAGS = '.$otherldflags.'
1962 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE)
1964 if ($armaybe ne ':'){
1965 $ldfrom = 'tmp$(LIB_EXT)';
1966 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1967 push(@m,' $(RANLIB) '."$ldfrom\n");
1969 $ldfrom = "-all $ldfrom -none" if ($osname eq 'dec_osf');
1970 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
1971 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(LDLOADLIBS) $(EXPORT_LIST) $(PERL_ARCHIVE)');
1974 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
1977 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1981 # --- Static Loading Sections ---
1986 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1987 $self = $ExtUtils::MakeMaker::Parent[-1];
1990 # $(INST_PM) has been moved to the all: target.
1991 # It remains here for awhile to allow for old usage: "make static"
1992 static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2000 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2001 $self = $ExtUtils::MakeMaker::Parent[-1];
2003 return '' unless $self->needs_linking(); #might be because of a subdir
2007 ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
2011 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2013 # If this extension has it's own library (eg SDBM_File)
2014 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2015 push(@m, " $self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2018 $(AR) cr $@ $(OBJECT) && $(RANLIB) $@
2019 @echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2021 @echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2024 # Old mechanism - still available:
2026 push(@m, <<'END') if $self->{PERL_SRC};
2027 @ echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2030 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2035 my($self, %attribs) = @_;
2037 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2038 $self = $ExtUtils::MakeMaker::Parent[-1];
2040 # By default .pm files are split into the architecture independent
2041 # library. This is a good thing. If a specific module requires that
2042 # it's .pm files are split into the architecture specific library
2043 # then it should use: installpm => {SPLITLIB=>'$(INST_ARCHLIB)'}
2044 # Note that installperl currently interferes with this (Config.pm)
2045 # User can disable split by saying: installpm => {SPLITLIB=>''}
2046 my($splitlib) = '$(INST_LIB)'; # NOT arch specific by default
2047 $splitlib = $attribs{SPLITLIB} if exists $attribs{SPLITLIB};
2049 push @m, "inst_pm :: \$(INST_PM)\n\n";
2050 foreach $dist (sort keys %{$self->{PM}}){
2051 my($inst) = $self->{PM}->{$dist};
2052 push(@m, "\n# installpm: $dist => $inst, splitlib=$splitlib\n");
2053 push(@m, $self->installpm_x($dist, $inst, $splitlib));
2059 sub installpm_x { # called by installpm per file
2060 my($self, $dist, $inst, $splitlib) = @_;
2062 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2063 $self = $ExtUtils::MakeMaker::Parent[-1];
2065 warn "Warning: Most probably 'make' will have problems processing this file: $inst\n"
2066 if $inst =~ m![:#]!;
2067 my($instdir) = $inst =~ m|(.*)/|;
2070 $inst: $dist $self->{MAKEFILE} $instdir/.exists
2071 ".' @ '.$self->{RM_F}.' $@
2072 $(UMASK_NULL) && '."$self->{CP} $dist".' $@
2073 @ echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2075 push(@m, "\t\@\$(AUTOSPLITFILE) \$@ $splitlib/auto\n")
2076 if ($splitlib and $inst =~ m/\.pm$/);
2078 push @m, $self->dir_target($instdir);
2083 my($self, %attribs) = @_;
2085 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2086 $self = $ExtUtils::MakeMaker::Parent[-1];
2088 return "\nmanifypods :\n" unless %{$self->{MANPODS}};
2091 if (defined $self->{PERL_SRC}) {
2092 $pod2man_exe = "$self->{PERL_SRC}/pod/pod2man";
2094 $pod2man_exe = "$Config{bin}/pod2man";
2096 unless ($self->maybe_command($pod2man_exe)) {
2097 # No pod2man but some MANPODS to be installed
2100 Warning: I could not locate your pod2man program. Please make sure,
2101 your pod2man program is in your PATH before you execute 'make'
2104 $pod2man_exe = "-S pod2man";
2108 qq[POD2MAN_EXE = $pod2man_exe\n],
2109 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2110 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2111 -e 'print "Installing $$m{$$_}\n";' \\
2112 -e 'system("$(PERL) $(POD2MAN_EXE) $$_>$$m{$$_}")==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2113 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2115 push @m, "\nmanifypods :";
2118 if (%{$self->{MANPODS}}) {
2119 push @m, "\t\@\$(POD2MAN) \\\t";
2120 push @m, join " \\\n\t", %{$self->{MANPODS}};
2128 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2129 $self = $ExtUtils::MakeMaker::Parent[-1];
2131 return "" unless $self->{PL_FILES};
2133 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2135 all :: $self->{PL_FILES}->{$plfile}
2137 $self->{PL_FILES}->{$plfile} :: $plfile
2138 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2146 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2147 my(@m, $from, $to, %fromto, @to);
2148 push @m, $self->dir_target(qw[$(INST_EXE)]);
2149 for $from (@{$self->{EXE_FILES}}) {
2150 my($path)= '$(INST_EXE)/' . basename($from);
2151 local($_) = $path; # for backwards compatibility
2152 $to = $self->exescan($path);
2153 print "exescan($from) => '$to'\n" if ($ExtUtils::MakeMaker::Verbose >=2);
2156 @to = values %fromto;
2158 EXE_FILES = @{$self->{EXE_FILES}}
2166 while (($from,$to) = each %fromto) {
2167 my $todir = dirname($to);
2169 $to: $from $self->{MAKEFILE} $todir/.exists
2170 $self->{CP} $from $to
2177 my($self,$path) = @_;
2180 # --- Sub-directory Sections ---
2185 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2186 $self = $ExtUtils::MakeMaker::Parent[-1];
2189 # This method provides a mechanism to automatically deal with
2190 # subdirectories containing further Makefile.PL scripts.
2191 # It calls the subdir_x() method for each subdirectory.
2192 foreach $dir (@{$self->{DIR}}){
2193 push(@m, $self->subdir_x($dir));
2194 #### print "Including $dir subdirectory\n";
2198 # The default clean, realclean and test targets in this Makefile
2199 # have automatically been given entries for each subdir.
2203 push(@m, "\n# none")
2208 sub runsubdirpl{ # Experimental! See subdir_x section
2209 my($self,$subdir) = @_;
2211 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2212 $self = $ExtUtils::MakeMaker::Parent[-1];
2214 chdir($subdir) or die "chdir($subdir): $!";
2215 #ExtUtils::MakeMaker::check_hints();
2217 require "Makefile.PL";
2221 my($self, $subdir) = @_;
2223 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2224 $self = $ExtUtils::MakeMaker::Parent[-1];
2230 \@-cd $subdir && \$(MAKE) all \$(PASTHRU)
2235 # --- Cleanup and Distribution Sections ---
2238 my($self, %attribs) = @_;
2240 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2241 $self = $ExtUtils::MakeMaker::Parent[-1];
2245 # Delete temporary files but do not touch installed files. We don\'t delete
2246 # the Makefile here so a later make realclean still has a makefile to use.
2250 # clean subdirectories first
2251 for $dir (@{$self->{DIR}}) {
2252 push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
2255 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
2256 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2257 push(@otherfiles, qw[./blib Makeaperlfile $(INST_ARCHAUTODIR)/extralibs.all
2258 perlmain.c mon.out core so_locations
2260 *$(OBJ_EXT) *$(LIB_EXT)
2261 perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
2263 push @m, "\t-$self->{RM_RF} @otherfiles\n";
2264 # See realclean and ext/utils/make_ext for usage of Makefile.old
2266 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
2268 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
2273 my($self, %attribs) = @_;
2275 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2276 $self = $ExtUtils::MakeMaker::Parent[-1];
2280 # Delete temporary files (via clean) and also delete installed files
2281 realclean purge :: clean
2283 # realclean subdirectories first (already cleaned)
2284 my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
2285 foreach(@{$self->{DIR}}){
2286 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2287 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2289 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2290 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2291 push(@m, " $self->{RM_F} \$(INST_STATIC) \$(INST_PM)\n");
2292 my(@otherfiles) = ($self->{MAKEFILE},
2293 "$self->{MAKEFILE}.old"); # Makefiles last
2294 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2295 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
2296 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
2303 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2304 $self = $ExtUtils::MakeMaker::Parent[-1];
2308 distclean :: realclean distcheck
2313 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
2319 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
2325 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
2334 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2335 $self = $ExtUtils::MakeMaker::Parent[-1];
2339 dist : $(DIST_DEFAULT)
2341 tardist : $(DISTVNAME).tar.$(SUFFIX)
2343 $(DISTVNAME).tar.$(SUFFIX) : distdir
2345 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
2346 $(RM_RF) $(DISTVNAME)
2347 $(COMPRESS) $(DISTVNAME).tar
2350 uutardist : $(DISTVNAME).tar.$(SUFFIX)
2351 uuencode $(DISTVNAME).tar.$(SUFFIX) \\
2352 $(DISTVNAME).tar.$(SUFFIX) > \\
2353 $(DISTVNAME).tar.$(SUFFIX).uu
2357 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
2358 $(RM_RF) $(DISTVNAME)
2367 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2368 $self = $ExtUtils::MakeMaker::Parent[-1];
2373 $(RM_RF) $(DISTVNAME)
2374 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "/mani/";' \\
2375 -e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
2383 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2384 $self = $ExtUtils::MakeMaker::Parent[-1];
2389 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
2390 cd $(DISTVNAME) && $(MAKE)
2391 cd $(DISTVNAME) && $(MAKE) test
2399 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2400 $self = $ExtUtils::MakeMaker::Parent[-1];
2405 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
2406 -e '@all = keys %{ maniread() };' \\
2407 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
2408 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
2414 my($self, %attribs) = @_;
2416 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2417 $self = $ExtUtils::MakeMaker::Parent[-1];
2422 @ echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2423 @ $(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \\
2424 -e "use ExtUtils::MakeMaker; MY->new({})->writedoc('Module', '$(NAME)', \\
2425 'LINKTYPE=$(LINKTYPE)', 'VERSION=$(VERSION)', \\
2426 'EXE_FILES=$(EXE_FILES)')" >> $(INSTALLARCHLIB)/perllocal.pod
2430 install :: pure_install doc_install
2434 # install subdirectories first
2435 push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) install\n",
2438 push(@m, "\t\@\$(PERL) \"-I\$(PERL_ARCHLIB)\" \"-I\$(PERL_LIB)\" -e 'require File::Path;' \\
2439 -e '\$\$message = q[ You do not have permissions to install into];' \\
2440 -e 'File::Path::mkpath(\@ARGV);' \\
2441 -e 'foreach (\@ARGV){ die qq{ \$\$message \$\$_\\n} unless -w \$\$_}' \\
2442 \$(INSTALLPRIVLIB) \$(INSTALLARCHLIB)
2443 \$(MAKE) INST_LIB=\$(INSTALLPRIVLIB) INST_ARCHLIB=\$(INSTALLARCHLIB) INST_EXE=\$(INSTALLBIN) INST_MAN1DIR=\$(INSTALLMAN1DIR) INST_MAN3DIR=\$(INSTALLMAN3DIR) all
2444 \@\$(PERL) -i.bak -lne 'print unless \$\$seen{ \$\$_ }++' \$(INSTALLARCHLIB)/auto/\$(FULLEXT)/.packlist
2448 #### UNINSTALL IS STILL EXPERIMENTAL ####
2452 push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) uninstall\n",
2454 push @m, "\t".'$(RM_RF) `cat $(INSTALLARCHLIB)/auto/$(FULLEXT)/.packlist`
2464 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2465 $self = $ExtUtils::MakeMaker::Parent[-1];
2467 '# Phony target to force checking subdirectories.
2476 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2477 $self = $ExtUtils::MakeMaker::Parent[-1];
2481 PERL_HDRS = $(PERL_INC)/EXTERN.h $(PERL_INC)/INTERN.h \
2482 $(PERL_INC)/XSUB.h $(PERL_INC)/av.h $(PERL_INC)/cop.h \
2483 $(PERL_INC)/cv.h $(PERL_INC)/dosish.h $(PERL_INC)/embed.h \
2484 $(PERL_INC)/form.h $(PERL_INC)/gv.h $(PERL_INC)/handy.h \
2485 $(PERL_INC)/hv.h $(PERL_INC)/keywords.h $(PERL_INC)/mg.h \
2486 $(PERL_INC)/op.h $(PERL_INC)/opcode.h $(PERL_INC)/patchlevel.h \
2487 $(PERL_INC)/perl.h $(PERL_INC)/perly.h $(PERL_INC)/pp.h \
2488 $(PERL_INC)/proto.h $(PERL_INC)/regcomp.h $(PERL_INC)/regexp.h \
2489 $(PERL_INC)/scope.h $(PERL_INC)/sv.h $(PERL_INC)/unixish.h \
2490 $(PERL_INC)/util.h $(PERL_INC)/config.h
2495 $(OBJECT) : $(PERL_HDRS)
2496 ' if $self->{OBJECT};
2499 # Check for unpropogated config.sh changes. Should never happen.
2500 # We do NOT just update config.h because that is not sufficient.
2501 # An out of date config.h is not fatal but complains loudly!
2502 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2503 -@echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2505 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2506 @echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2507 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2508 ') if $self->{PERL_SRC};
2510 push(@m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n")
2518 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2519 $self = $ExtUtils::MakeMaker::Parent[-1];
2522 # We do not know what target was originally specified so we
2523 # must force a manual rerun to be sure. But as it should only
2524 # happen very rarely it is not a significant problem.
2526 $(OBJECT) : $(FIRST_MAKEFILE)
2527 ' if $self->{OBJECT};
2530 # We take a very conservative approach here, but it\'s worth it.
2531 # We move Makefile to Makefile.old here to avoid gnu make looping.
2532 '.$self->{MAKEFILE}.' : Makefile.PL $(CONFIGDEP)
2533 @echo "Makefile out-of-date with respect to $?"
2534 @echo "Cleaning current config before rebuilding Makefile..."
2535 -@mv '."$self->{MAKEFILE} $self->{MAKEFILE}.old".'
2536 -$(MAKE) -f '.$self->{MAKEFILE}.'.old clean >/dev/null 2>&1 || true
2537 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL '."@ARGV".'
2538 @echo ">>> Your Makefile has been rebuilt. <<<"
2539 @echo ">>> Please rerun the make command. <<<"; false
2546 my($self, %attribs) = @_;
2548 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2549 $self = $ExtUtils::MakeMaker::Parent[-1];
2553 my(%searchdirs)=($self->{PERL_ARCHLIB} => 1, $self->{INST_ARCHLIB} => 1);
2554 my(@searchdirs)=keys %searchdirs;
2556 # And as it's not yet built, we add the current extension
2557 # but only if it has some C code (or XS code, which implies C code)
2558 if (@{$self->{C}}) {
2559 @static="$self->{INST_ARCHLIB}/auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}";
2562 # Either we determine now, which libraries we will produce in the
2563 # subdirectories or we do it at runtime of the make.
2565 # We could ask all subdir objects, but I cannot imagine, why it
2566 # would be necessary.
2568 # Instead we determine all libraries for the new perl at
2570 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2572 $self->makeaperl(MAKE => $self->{MAKEFILE},
2573 DIRS => \@searchdirs,
2576 TARGET => $self->{MAP_TARGET},
2578 LIBPERL => $self->{LIBPERL_A}
2582 # --- Test and Installation Sections ---
2585 my($self, %attribs) = @_;
2587 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2588 $self = $ExtUtils::MakeMaker::Parent[-1];
2590 my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2594 TEST_TYPE=test_\$(LINKTYPE)
2596 test :: \$(TEST_TYPE)
2598 push(@m, map("\t\@cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2600 push(@m, "\t\@echo 'No tests defined for \$(NAME) extension.'\n")
2601 unless $tests or -f "test.pl" or @{$self->{DIR}};
2604 push(@m, "test_dynamic :: all\n");
2605 push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2606 push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2609 # Occasionally we may face this degenerated target:
2610 push @m, "test_ : test_dynamic\n\n";
2612 if ($self->needs_linking()) {
2613 push(@m, "test_static :: all \$(MAP_TARGET)\n");
2614 push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2615 push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2618 push @m, "test_static :: test_dynamic\n";
2623 sub test_via_harness {
2624 my($self, $perl, $tests) = @_;
2626 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2627 $self = $ExtUtils::MakeMaker::Parent[-1];
2629 "\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";
2632 sub test_via_script {
2633 my($self, $perl, $script) = @_;
2635 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2636 $self = $ExtUtils::MakeMaker::Parent[-1];
2638 "\tPERL_DL_NONLAZY=1 $perl".' -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) test.pl
2646 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2647 $self = $ExtUtils::MakeMaker::Parent[-1];
2653 my($self, %attribs) = @_;
2655 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2656 $self = $ExtUtils::MakeMaker::Parent[-1];
2658 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2659 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2662 # --- MakeMaker makeaperl section ---
2663 MAP_TARGET = $target
2664 FULLPERL = $self->{FULLPERL}
2666 return join '', @m if $self->{PARENT};
2668 my($dir) = join ":", @{$self->{DIR}};
2670 unless ($self->{MAKEAPERL}) {
2672 $(MAP_TARGET) :: $(MAKE_APERL_FILE)
2673 $(MAKE) -f Makefile.aperl static $@
2675 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2676 @ echo Writing \"Makefile.aperl\" for this $(MAP_TARGET)
2677 @ $(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2678 Makefile.PL DIR=}, $dir, q{ \
2679 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2680 MAKEAPERL=1 NORECURS=1};
2682 push @m, map( " \\\n\t\t$_", @ARGV );
2690 my($cccmd, $linkcmd, $lperl);
2693 $cccmd = $self->const_cccmd($libperl);
2694 $cccmd =~ s/^CCCMD\s*=\s*//;
2695 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2696 $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
2697 $cccmd =~ s/\n/ /g; # yes I've seen "\n", don't ask me where it came from. A.K.
2699 # The front matter of the linkcommand...
2700 $linkcmd = join ' ', "\$(CC)",
2701 grep($_, @Config{qw(large split ldflags ccdlflags)});
2702 $linkcmd =~ s/\s+/ /g;
2704 # Which *.a files could we make use of...
2706 File::Find::find(sub {
2707 return unless m/\Q$self->{LIB_EXT}$/;
2708 return if m/^libperl/;
2709 # don't include the installed version of this extension. I
2710 # leave this line here, although it is not necessary anymore:
2711 # I patched minimod.PL instead, so that Miniperl.pm won't
2712 # enclude duplicates
2714 # Once the patch to minimod.PL is in the distribution, I can
2716 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2717 $static{fastcwd() . "/" . $_}++;
2718 }, grep( -d $_, @{$searchdirs || []}) );
2720 # We trust that what has been handed in as argument, will be buildable
2721 $static = [] unless $static;
2722 @static{@{$static}} = (1) x @{$static};
2724 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2725 for (sort keys %static) {
2726 next unless /\Q$self->{LIB_EXT}$/;
2727 $_ = dirname($_) . "/extralibs.ld";
2731 grep(s/^/-I/, @{$perlinc || []});
2733 $target = "perl" unless $target;
2734 $tmp = "." unless $tmp;
2736 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2737 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2738 # extralibs.all are computed correctly
2740 MAP_LINKCMD = $linkcmd
2741 MAP_PERLINC = @{$perlinc || []}
2743 join(" \\\n\t", reverse sort keys %static), "
2745 MAP_PRELIBS = $Config::Config{libs} $Config::Config{cryptlib}
2748 if (defined $libperl) {
2749 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2751 unless ($libperl && -f $lperl) { # Could quite follow your idea her, Ilya
2752 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2753 $libperl ||= "libperl$self->{LIB_EXT}";
2754 $libperl = "$dir/$libperl";
2755 $lperl ||= "libperl$self->{LIB_EXT}";
2756 $lperl = "$dir/$lperl";
2757 print STDOUT "Warning: $libperl not found
2758 If you're going to build a static perl binary, make sure perl is installed
2759 otherwise ignore this warning\n"
2760 unless (-f $lperl || defined($self->{PERL_SRC}));
2764 MAP_LIBPERL = $libperl
2768 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2769 \@ $self->{RM_F} \$\@
2774 foreach $catfile (@$extra){
2775 push @m, "\tcat $catfile >> \$\@\n";
2779 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2780 \$(MAP_LINKCMD) -o \$\@ $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2781 @ echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2782 @ echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2783 @ echo 'To remove the intermediate files say'
2784 @ echo ' make -f $makefilename map_clean'
2786 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2788 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2791 $tmp/perlmain.c: $makefilename}, q{
2793 @ $(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
2794 writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
2798 # We write EXTRA outside the perl program to have it eval'd by the shell
2801 @ echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2802 @ $(FULLPERL) -e 'use ExtUtils::MakeMaker; MY->new->writedoc("Perl binary",' \\
2803 -e '"$(MAP_TARGET)", "MAP_STATIC=$(MAP_STATIC)",' \\
2804 -e '"MAP_EXTRA=@ARGV", "MAP_LIBPERL=$(MAP_LIBPERL)")' \\
2805 -- `cat $(INST_ARCHAUTODIR)/extralibs.all` >> $(INSTALLARCHLIB)/perllocal.pod
2809 inst_perl: pure_inst_perl doc_inst_perl
2811 pure_inst_perl: \$(MAP_TARGET)
2812 $self->{CP} \$(MAP_TARGET) \$(INSTALLBIN)/\$(MAP_TARGET)
2817 $self->{RM_F} $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2824 my($self,$libs) = @_;
2826 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2827 $self = $ExtUtils::MakeMaker::Parent[-1];
2829 require ExtUtils::Liblist;
2830 ExtUtils::Liblist::ext($libs, $ExtUtils::MakeMaker::Verbose);
2836 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2837 $self = $ExtUtils::MakeMaker::Parent[-1];
2841 # only AIX requires a symbol list at this point
2842 # (so does VMS, but that's handled by the MM_VMS package)
2843 return '' unless $Config::Config{osname} eq 'aix';
2845 $self->init_main(@ARGV) unless defined $self->{BASEEXT};
2846 if (! $self->{DL_FUNCS}) {
2848 ($bootfunc = $self->{NAME}) =~ s/\W/_/g;
2849 $self->{DL_FUNCS} = {$self->{BASEEXT} => ["boot_$bootfunc"]};
2851 rename "$self->{BASEEXT}.exp", "$self->{BASEEXT}.exp_old";
2853 open(EXP,">$self->{BASEEXT}.exp") or die $!;
2854 print EXP join("\n",@{$self->{DL_VARS}}, "\n") if $self->{DL_VARS};
2855 foreach $pkg (keys %{$self->{DL_FUNCS}}) {
2856 (my($prefix) = $pkg) =~ s/\W/_/g;
2858 foreach $func (@{$self->{DL_FUNCS}->{$pkg}}) {
2859 $func = "XS_${prefix}_$func" unless $func =~ /^boot_/;
2860 print EXP "$func\n";
2866 # --- Make-Directories section (internal method) ---
2867 # dir_target(@array) returns a Makefile entry for the file .exists in each
2868 # named directory. Returns nothing, if the entry has already been processed.
2869 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
2870 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
2871 # prerequisite, because there has to be one, something that doesn't change
2875 my($self,@dirs) = @_;
2877 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2878 $self = $ExtUtils::MakeMaker::Parent[-1];
2881 foreach $dir (@dirs) {
2882 next if $self->{DIR_TARGET}{$self}{$dir}++;
2884 $dir/.exists :: \$(PERL)
2886 \@ \$(TOUCH) $dir/.exists
2887 \@-\$(CHMOD) 755 $dir
2893 # --- Output postprocessing section ---
2894 # nicetext is included to make VMS support easier
2895 sub nicetext { # Just return the input - no action needed
2896 my($self,$text) = @_;
2898 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2899 $self = $ExtUtils::MakeMaker::Parent[-1];
2904 sub needs_linking { # Does this module need linking? Looks into
2905 # subdirectory objects (see also has_link_code()
2908 $caller = (caller(0))[3];
2910 ExtUtils::MakeMaker::TieAtt::warndirectuse($caller);
2911 $self = $ExtUtils::MakeMaker::Parent[-1];
2913 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2914 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2916 # print Carp::longmess();
2917 # print "EO_DEBUG\n";
2918 if ($self->has_link_code or $self->{MAKEAPERL}){
2919 $self->{NEEDS_LINKING} = 1;
2922 foreach $child (keys %{$self->{CHILDREN}}) {
2923 if ($self->{CHILDREN}->{$child}->needs_linking) {
2924 $self->{NEEDS_LINKING} = 1;
2928 return $self->{NEEDS_LINKING} = 0;
2933 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
2934 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
2935 $self->{HAS_LINK_CODE} = 1;
2938 return $self->{HAS_LINK_CODE} = 0;
2941 # --- perllocal.pod section ---
2943 my($self,$what,$name,@attribs)=@_;
2945 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2946 $self = $ExtUtils::MakeMaker::Parent[-1];
2950 chop($time = ctime(time));
2951 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
2952 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
2953 print "\n\n=back\n\n";
2956 sub catdir { shift; join('/',@_); }
2957 sub catfile { shift; join('/',@_); }
2959 package ExtUtils::MM_OS2;
2963 #use File::Basename;
2966 Exporter::import('ExtUtils::MakeMaker',
2970 my($self,%attribs) = @_;
2972 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
2973 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
2975 (my $boot = $self->{NAME}) =~ s/:/_/g;
2977 if (not $self->{SKIPHASH}{'dynamic'}) {
2979 $self->{BASEEXT}.def: Makefile.PL"
2981 echo "LIBRARY ' . "'$self->{DLBASE}'" . ' INITINSTANCE TERMINSTANCE" > $@ ; \\
2982 echo "CODE LOADONCALL" >> $@ ; \\
2983 echo "DATA LOADONCALL NONSHARED MULTIPLE" >> $@ ; \\
2984 echo "EXPORTS" >> $@ ; \\
2985 echo " ' . "boot_$boot" . '" >> $@');
2986 foreach $sym (keys %$funcs, @$vars) {
2988 echo \" $sym\" >> \$@");
2996 sub replace_manpage_seperator {
2997 my($self,$man) = @_;
3003 my($self,$file) = @_;
3004 return 1 if -x $file && ! -d _;
3005 return 1 if -x "$file.exe" && ! -d _;
3009 # the following keeps AutoSplit happy
3010 package ExtUtils::MakeMaker;
3017 ExtUtils::MakeMaker - create an extension Makefile
3021 C<use ExtUtils::MakeMaker;>
3023 C<WriteMakefile( ATTRIBUTE =E<gt> VALUE [, ...] );>
3027 C<MM-E<gt>new(\%att)-E<gt>flush;>
3031 This utility is designed to write a Makefile for an extension module
3032 from a Makefile.PL. It is based on the Makefile.SH model provided by
3033 Andy Dougherty and the perl5-porters.
3035 It splits the task of generating the Makefile into several subroutines
3036 that can be individually overridden. Each subroutine returns the text
3037 it wishes to have written to the Makefile.
3039 =head2 Hintsfile support
3041 MakeMaker.pm uses the architecture specific information from
3042 Config.pm. In addition it evaluates architecture specific hints files
3043 in a C<hints/> directory. The hints files are expected to be named
3044 like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
3045 name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
3046 MakeMaker within the WriteMakefile() subroutine, and can be used to
3047 execute commands as well as to include special variables. The rules
3048 which hintsfile is chosen are the same as in Configure.
3050 The hintsfile is eval()ed immediately after the arguments given to
3051 WriteMakefile are stuffed into a hash reference $self but before this
3052 reference becomes blessed. So if you want to do the equivalent to
3053 override or create an attribute you would say something like
3055 $self->{LIBS} = ['-ldbm -lucb -lc'];
3057 =head2 What's new in version 5 of MakeMaker
3059 MakeMaker 5 is pure object oriented. This allows us to write an
3060 unlimited number of Makefiles with a single perl process. 'perl
3061 Makefile.PL' with MakeMaker 5 goes through all subdirectories
3062 immediately and evaluates any Makefile.PL found in the next level
3063 subdirectories. The benefit of this approach comes in useful for both
3064 single and multi directories extensions.
3066 Multi directory extensions have an immediately visible speed
3067 advantage, because there's no startup penalty for any single
3068 subdirectory Makefile.
3070 Single directory packages benefit from the much improved
3071 needs_linking() method. As the main Makefile knows everything about
3072 the subdirectories, a needs_linking() method can now query all
3073 subdirectories if there is any linking involved down in the tree. The
3074 speedup for PM-only Makefiles seems to be around 1 second on my
3077 =head2 Incompatibilities between MakeMaker 5.00 and 4.23
3079 There are no incompatibilities in the short term, as all changes are
3080 accompanied by short-term workarounds that guarantee full backwards
3083 You are likely to face a few warnings that expose deprecations which
3084 will result in incompatibilities in the long run:
3086 You should not use %att directly anymore. Instead any subroutine you
3087 override in the MY package will be called by the object method, so you
3088 can access all object attributes directly via the object in $_[0].
3090 You should not call the class methos MM->something anymore. Instead
3091 you should call the superclass. Something like
3096 $self->MM::constants();
3099 Especially the libscan() and exescan() methods should be altered
3100 towards OO programming, that means do not expect that $_ to contain
3101 the path but rather $_[1].
3103 You should program with more care. Watch out for any MakeMaker
3104 variables. Do not try to alter them, somebody else might depend on
3105 them. E.g. do not overwrite the ExtUtils::MakeMaker::VERSION variable
3106 (this happens if you import it and then set it to the version number
3107 of your package), do not expect that the INST_LIB variable will be
3108 ./blib (do not 'unshift @INC, "./blib" and do not use
3109 "blib/FindBin.pm"). Do not croak in your Makefile.PL, let it fail with
3112 Try to build several extensions simultanously to debug your
3113 Makefile.PL. You can unpack a bunch of distributed packages, so your
3114 directory looks like
3116 Alias-1.00/ Net-FTP-1.01a/ Set-Scalar-0.001/
3117 ExtUtils-Peek-0.4/ Net-Ping-1.00/ SetDualVar-1.0/
3118 Filter-1.06/ NetTools-1.01a/ Storable-0.1/
3119 GD-1.00/ Religion-1.04/ Sys-Domain-1.05/
3120 MailTools-1.03/ SNMP-1.5b/ Term-ReadLine-0.7/
3122 and write a dummy Makefile.PL that contains nothing but
3124 use ExtUtils::MakeMaker;
3127 That's actually fun to watch :)
3129 Final suggestion: Try to delete all of your MY:: subroutines and
3130 watch, if you really still need them. MakeMaker might already do what
3131 you want without them. That's all about it.
3134 =head2 Default Makefile Behaviour
3136 The automatically generated Makefile enables the user of the extension
3139 perl Makefile.PL # optionally "perl Makefile.PL verbose"
3141 make test # optionally set TEST_VERBOSE=1
3142 make install # See below
3144 The Makefile to be produced may be altered by adding arguments of the
3145 form C<KEY=VALUE>. If the user wants to work with a different perl
3146 than the default, this can be achieved with
3148 perl Makefile.PL PERL=/tmp/myperl5
3150 Other interesting targets in the generated Makefile are
3152 make config # to check if the Makefile is up-to-date
3153 make clean # delete local temp files (Makefile gets renamed)
3154 make realclean # delete derived files (including ./blib)
3155 make dist # see below the Distribution Support section
3157 =head2 Special case make install
3159 make alone puts all relevant files into directories that are named by
3160 the macros INST_LIB, INST_ARCHLIB, INST_EXE, INST_MAN1DIR, and
3161 INST_MAN3DIR. All these default to ./blib or something below blib if
3162 you are I<not> building below the perl source directory. If you I<are>
3163 building below the perl source, INST_LIB and INST_ARCHLIB default to
3164 ../../lib, and INST_EXE is not defined.
3166 The I<install> target of the generated Makefile is a recursive call to
3169 INST_LIB to INSTALLPRIVLIB
3170 INST_ARCHLIB to INSTALLARCHLIB
3171 INST_EXE to INSTALLBIN
3172 INST_MAN1DIR to INSTALLMAN1DIR
3173 INST_MAN3DIR to INSTALLMAN3DIR
3175 The INSTALL... macros in turn default to their %Config
3176 ($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts.
3178 The recommended way to proceed is to set only the INSTALL* macros, not
3179 the INST_* targets. In doing so, you give room to the compilation
3180 process without affecting important directories. Usually a make
3181 test will succeed after the make, and a make install can finish
3184 MakeMaker gives you much more freedom than needed to configure
3185 internal variables and get different results. It is worth to mention,
3186 that make(1) also lets you configure most of the variables that are
3187 used in the Makefile. But in the majority of situations this will not
3188 be necessary, and should only be done, if the author of a package
3191 The usual relationship between INSTALLPRIVLIB and INSTALLARCHLIB is
3192 that the latter is a subdirectory of the former with the name
3193 C<$Config{archname}>, MakeMaker supports the user who sets
3194 INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not, then
3195 MakeMaker defaults the latter to be INSTALLPRIVLIB/ARCHNAME if that
3196 directory exists, otherwise it defaults to INSTALLPRIVLIB.
3199 =head2 PREFIX attribute
3201 The PREFIX attribute can be used to set the INSTALL*
3202 attributes in one go. This is the quickest way to install a module in
3203 a non-standard place.
3205 perl Makefile.PL PREFIX=~
3207 This is identical to
3209 perl Makefile.PL INSTALLPRIVLIB=~/perl5/lib INSTALLBIN=~/bin \
3210 INSTAMAN1DIR=~/perl5/man/man1 INSTALLMAN3DIR=~/perl5/man/man3
3212 Note, that the tilde expansion is done by MakeMaker, not by perl by
3213 default, nor by make.
3215 It is important to know, that the INSTALL* macros should be absolute
3216 paths, never relativ ones. Packages with multiple Makefile.PLs in
3217 different directories get the contents of the INSTALL* macros
3218 propagated verbatim. (The INST_* macros will be corrected, if they are
3219 relativ paths, but not the INSTALL* macros.)
3221 If the user has superuser privileges, and is not working on AFS
3222 (Andrew File System) or relatives, then the defaults for
3223 INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLBIN, etc. will be appropriate,
3224 and this incantation will be the best:
3226 perl Makefile.PL; make; make test
3229 make install per default writes some documentation of what has been
3230 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This is
3231 an experimental feature. It can be bypassed by calling make
3236 will have to specify the installation directories as these most
3237 probably have changed since perl itself has been installed. They will
3238 have to do this by calling
3240 perl Makefile.PL INSTALLPRIVLIB=/afs/here/today \
3241 INSTALLBIN=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
3244 In nested extensions with many subdirectories, the INSTALL* arguments
3245 will get propagated to the subdirectories. Be careful to repeat this
3246 procedure every time you recompile an extension, unless you are sure
3247 the AFS istallation directories are still valid.
3251 =head2 Static Linking of a new Perl Binary
3253 An extension that is built with the above steps is ready to use on
3254 systems supporting dynamic loading. On systems that do not support
3255 dynamic loading, any newly created extension has to be linked together
3256 with the available resources. MakeMaker supports the linking process
3257 by creating appropriate targets in the Makefile whenever an extension
3258 is built. You can invoke the corresponding section of the makefile with
3262 That produces a new perl binary in the current directory with all
3263 extensions linked in that can be found in INST_ARCHLIB (which usually
3264 is C<./blib>) and PERL_ARCHLIB. To do that, MakeMaker writes a new
3265 Makefile, on UNIX, this is called Makefile.aperl (may be system
3266 dependent). If you want to force the creation of a new perl, it is
3267 recommended, that you delete this Makefile.aperl, so INST_ARCHLIB and
3268 PERL_ARCHLIB are searched-through for linkable libraries again.
3270 The binary can be installed into the directory where perl normally
3271 resides on your machine with
3275 To produce a perl binary with a different name than C<perl>, either say
3277 perl Makefile.PL MAP_TARGET=myperl
3284 make myperl MAP_TARGET=myperl
3285 make inst_perl MAP_TARGET=myperl
3287 In any case you will be prompted with the correct invocation of the
3288 C<inst_perl> target that installs the new binary into INSTALLBIN.
3290 Note, that there is a C<makeaperl> scipt in the perl distribution,
3291 that supports the linking of a new perl binary in a similar fashion,
3292 but with more options.
3294 make inst_perl per default writes some documentation of what has been
3295 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This
3296 can be bypassed by calling make pure_inst_perl.
3298 Warning: the inst_perl: target is rather mighty and will probably
3299 overwrite your existing perl binary. Use with care!
3301 Sometimes you might want to build a statically linked perl although
3302 your system supports dynamic loading. In this case you may explicitly
3303 set the linktype with the invocation of the Makefile.PL or make:
3305 perl Makefile.PL LINKTYPE=static # recommended
3309 make LINKTYPE=static # works on most systems
3311 =head2 Determination of Perl Library and Installation Locations
3313 MakeMaker needs to know, or to guess, where certain things are
3314 located. Especially INST_LIB and INST_ARCHLIB (where to install files
3315 into), PERL_LIB and PERL_ARCHLIB (where to read existing modules
3316 from), and PERL_INC (header files and C<libperl*.*>).
3318 Extensions may be built either using the contents of the perl source
3319 directory tree or from an installed copy of the perl library.
3321 If an extension is being built below the C<ext/> directory of the perl
3322 source then MakeMaker will set PERL_SRC automatically (e.g., C<../..>).
3323 If PERL_SRC is defined then other variables default to the following:
3326 PERL_LIB = PERL_SRC/lib
3327 PERL_ARCHLIB = PERL_SRC/lib
3329 INST_ARCHLIB = PERL_ARCHLIB
3331 If an extension is being built away from the perl source then MakeMaker
3332 will leave PERL_SRC undefined and default to using the installed copy
3333 of the perl library. The other variables default to the following:
3335 PERL_INC = $archlib/CORE
3337 PERL_ARCHLIB = $archlib
3339 INST_ARCHLIB = ./blib/<archname>
3341 If perl has not yet been installed then PERL_SRC can be defined on the
3342 command line as shown in the previous section.
3344 =head2 Useful Default Makefile Macros
3346 FULLEXT = Pathname for extension directory (eg DBD/Oracle).
3348 BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
3350 ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
3352 INST_LIBDIR = C<$(INST_LIB)$(ROOTEXT)>
3354 INST_AUTODIR = C<$(INST_LIB)/auto/$(FULLEXT)>
3356 INST_ARCHAUTODIR = C<$(INST_ARCHLIB)/auto/$(FULLEXT)>
3358 =head2 Using Attributes (and Parameters)
3360 The following attributes can be specified as arguments to WriteMakefile()
3361 or as NAME=VALUE pairs on the command line:
3365 # The following "=item NAME" is used by the attrib_help routine
3366 # likewise the "=back" below. So be careful when changing it!
3372 Perl module name for this extension (DBD::Oracle). This will default
3373 to the directory name but should be explicitly defined in the
3378 Your name for distributing the package (by tar file) This defaults to
3383 Your version number for distributing the package. This defaults to
3388 CODE reference. Extension writers are requested to do all their
3389 initializing within that subroutine. The subroutine
3390 should return a hash reference. The hash may contain
3391 further attributes, e.g. {LIBS => ...}, that have to
3392 be determined by some evaluation method.
3396 MakeMaker will figure out, if an extension contains linkable code
3397 anywhere down the directory tree, but you can speed him up a little
3398 bit, if you define this boolean variable yourself. Extensions that do
3399 not need linking will be given a reduced Makefile yielding a
3400 considerable speedadvantage.
3404 Directory where we put library files of this extension while building
3407 =item INSTALLPRIVLIB
3409 Used by 'make install', which sets INST_LIB to this value.
3413 Same as INST_LIB for architecture dependent files.
3415 =item INSTALLARCHLIB
3417 Used by 'make install', which sets INST_ARCHLIB to this value.
3421 Directory, where executable scripts should be installed during
3422 'make'. Defaults to "./blib/ARCHNAME", just to have a dummy
3423 location during testing. make install will set
3424 INST_EXE to INSTALLBIN.
3428 Used by 'make install' which sets INST_EXE to this value.
3434 These directories get the man pages at 'make' time
3436 =item INSTALLMAN1DIR
3438 =item INSTALLMAN3DIR
3440 These directories get the man pages at 'make install' time
3444 Can be used to set the three INSTALL* attributes above in one go.
3445 They will have PREFIX as a common directory node and
3446 will branch from that node into lib/, lib/ARCHNAME,
3447 and bin/ unless you override one of them.
3451 Directory containing the Perl library to use.
3455 Same as above for architecture dependent files
3459 Directory containing the Perl source code (use of this should be
3460 avoided, it may be undefined)
3464 Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
3468 Something like C<"-DHAVE_UNISTD_H">
3472 List of object files, defaults to '$(BASEEXT)$(OBJ_EXT)', but can be a long
3473 string containing all object files, e.g. "tkpBind.o
3474 tkpButton.o tkpCanvas.o"
3478 If the extension links to a library that it builds set this to the
3479 name of the library (see SDBM_File)
3483 An anonymous array of alternative library
3484 specifications to be searched for (in order) until
3485 at least one library is found. E.g.
3487 'LIBS' => ["-lgdbm", "-ldbm -lfoo", "-L/path -ldbm.nfs"]
3489 Mind, that any element of the array
3490 contains a complete set of arguments for the ld
3491 command. So do not specify
3493 'LIBS' => ["-ltcl", "-ltk", "-lX11"]
3495 See ODBM_File/Makefile.PL for an example, where an array is needed. If
3496 you specify a scalar as in
3498 'LIBS' => "-ltcl -ltk -lX11"
3500 MakeMaker will turn it into an array with one element.
3504 defaults to "$(OBJECT)" and is used in the ld command to specify
3505 what files to link/load from (also see dynamic_lib below for how to
3510 Ref to array of subdirectories containing Makefile.PLs e.g. [ 'sdbm'
3515 Ref to array of subdirectories containing library files. Defaults to
3516 [ 'lib', $(BASEEXT) ]. The directories will be scanned and any files
3517 they contain will be installed in the corresponding location in the
3518 library. A libscan() method can be used to alter the behaviour.
3519 Defining PM in the Makefile.PL will override PMLIBDIRS.
3523 Hashref of .pm files and *.pl files to be installed. e.g.
3525 {'name_of_file.pm' => '$(INST_LIBDIR)/install_as.pm'}
3527 By default this will include *.pm and *.pl. If a lib directory
3528 exists and is not listed in DIR (above) then any *.pm and *.pl files
3529 it contains will also be included by default. Defining PM in the
3530 Makefile.PL will override PMLIBDIRS.
3534 Hashref of .xs files. MakeMaker will default this. e.g.
3536 {'name_of_file.xs' => 'name_of_file.c'}
3538 The .c files will automatically be included in the list of files
3539 deleted by a make clean.
3543 String of options to pass to xsubpp. This might include C<-C++> or
3544 C<-extern>. Do not include typemaps here; the TYPEMAP parameter exists for
3549 Ref to array of *.c file names. Initialised from a directory scan
3550 and the values portion of the XS attribute hash. This is not
3551 currently used by MakeMaker but may be handy in Makefile.PLs.
3555 Ref to array of *.h file names. Similar to C above.
3559 Ref to array of typemap file names. Use this when the typemaps are
3560 in some directory other than the current directory or when they are
3561 not named B<typemap>. The last typemap in the list takes
3562 precedence. A typemap in the current directory has highest
3563 precedence, even if it isn't listed in TYPEMAPS. The default system
3564 typemap has lowest precedence.
3568 Ref to hash of files to be processed as perl programs. MakeMaker
3569 will default to any found *.PL file (except Makefile.PL) being keys
3570 and the basename of the file being the value. E.g.
3572 {'foobar.PL' => 'foobar'}
3574 The *.PL files are expected to produce output to the target files
3579 Ref to array of executable files. The files will be copied to the
3580 INST_EXE directory. Make realclean will delete them from there
3585 'static' or 'dynamic' (default unless usedl=undef in config.sh) Should
3586 only be used to force static linking (also see
3591 Hashref of symbol names for routines to be made available as
3592 universal symbols. Each key/value pair consists of the package name
3593 and an array of routine names in that package. Used only under AIX
3594 (export lists) and VMS (linker options) at present. The routine
3595 names supplied will be expanded in the same way as XSUB names are
3596 expanded by the XS() macro. Defaults to
3598 {"$(NAME)" => ["boot_$(NAME)" ] }
3602 {"RPC" => [qw( boot_rpcb rpcb_gettime getnetconfigent )],
3603 "NetconfigPtr" => [ 'DESTROY'] }
3607 Array of symbol names for variables to be made available as
3608 universal symbols. Used only under AIX (export lists) and VMS
3609 (linker options) at present. Defaults to []. (e.g. [ qw(
3610 Foo_version Foo_numstreams Foo_tree ) ])
3614 Arrayref. E.g. [qw(archname manext)] defines ARCHNAME & MANEXT from
3619 Arryref. E.g. [qw(name1 name2)] skip (do not write) sections of the
3624 If it is intended, that a new perl binary be produced, this variable
3625 may hold a name for that binary. Defaults to perl
3629 The filename of the perllibrary that will be used together with this
3630 extension. Defaults to libperl.a.
3634 Perl binary for tasks that can be done by miniperl
3638 Perl binary able to run this extension.
3642 Hashref. Names of modules that need to be available to run this
3643 extension (e.g. Fcntl for SDBM_File) are the keys of the hash and
3644 the desired version is the value. (Not yet implemented!)
3648 Boolean. Experimental attribute to inhibit descending into
3653 Hashref of .pm and .pod files. MakeMaker will default this to all
3654 .pod and any .pm files that include POD directives. The files listed
3655 here will be converted to man pages and installed as was requested
3660 Boolean which tells MakeMaker, that it should include the rules to
3661 make a perl. This is handled automatically as a switch by
3662 MakeMaker. The user normally does not need it.
3664 =item FIRST_MAKEFILE
3668 The name of the Makefile to be produced.
3672 The call to the program that is able to compile perlmain.c. Defaults
3677 =head2 Additional lowercase attributes
3679 can be used to pass parameters to the methods which implement that
3680 part of the Makefile. These are not normally required:
3686 {ANY_MACRO => ANY_VALUE, ...}
3690 {SPLITLIB => '$(INST_LIB)' (default) or '$(INST_ARCHLIB)'}
3694 {LINKTYPE => 'static', 'dynamic' or ''}
3696 NB: Extensions that have nothing but *.pm files or have the role of
3697 holding together several subdirectories specify
3703 {ARMAYBE => 'ar', OTHERLDFLAGS => '...'}
3707 {FILES => "*.xyz foo"}
3711 {FILES => '$(INST_ARCHAUTODIR)/*.xyz'}
3715 {TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => 'gz',
3716 SHAR => 'shar -m', DIST_CP => 'ln'}
3718 If you specify COMPRESS, then SUFFIX should also be altered, as it is
3719 needed to tell make the target file of the compression. Setting
3720 DIST_CP to ln can be useful, if you need to preserve the timestamps on
3721 your files. DIST_CP can take the values 'cp', which copies the file,
3722 'ln', which links the file, and 'best' which copies symbolic links and
3723 links the rest. Default is 'best'.
3725 =item tool_autosplit
3733 # bug in pod2html, so leave the =back
3735 # Don't delete this cut, MM depends on it!
3737 =head2 Overriding MakeMaker Methods
3739 If you cannot achieve the desired Makefile behaviour by specifying
3740 attributes you may define private subroutines in the Makefile.PL.
3741 Each subroutines returns the text it wishes to have written to
3742 the Makefile. To override a section of the Makefile you can
3745 sub MY::c_o { "new literal text" }
3747 or you can edit the default by saying something like:
3753 s/old text/new text/;
3757 Both methods above are available for backwards compatibility with
3760 If you still need a different solution, try to develop another
3761 subroutine, that fits your needs and submit the diffs to
3762 F<perl5-porters@nicoh.com> or F<comp.lang.perl.misc> as appropriate.
3764 =head2 Distribution Support
3766 For authors of extensions MakeMaker provides several Makefile
3767 targets. Most of the support comes from the ExtUtils::Manifest module,
3768 where additional documentation can be found.
3772 =item make distcheck
3774 reports which files are below the build directory but not in the
3775 MANIFEST file and vice versa. (See ExtUtils::Manifest::fullcheck() for
3778 =item make skipcheck
3780 reports which files are skipped due to the entries in the
3781 C<MANIFEST.SKIP> file (See ExtUtils::Manifest::skipcheck() for
3784 =item make distclean
3786 does a realclean first and then the distcheck. Note that this is not
3787 needed to build a new distribution as long as you are sure, that the
3788 MANIFEST file is ok.
3792 rewrites the MANIFEST file, adding all remaining files found (See
3793 ExtUtils::Manifest::mkmanifest() for details)
3797 Copies all the files that are in the MANIFEST file to a newly created
3798 directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory
3799 exists, it will be removed first.
3803 Makes a distdir first, and runs a C<perl Makefile.PL>, a make, and
3804 a make test in that directory.
3808 First does a command $(PREOP) which defaults to a null command. Does a
3809 distdir next and runs C<tar> on that directory into a tarfile. Then
3810 deletes the distdir. Finishes with a command $(POSTOP) which defaults
3815 Defaults to $(DIST_DEFAULT) which in turn defaults to tardist.
3817 =item make uutardist
3819 Runs a tardist first and uuencodes the tarfile.
3823 First does a command $(PREOP) which defaults to a null command. Does a
3824 distdir next and runs C<shar> on that directory into a sharfile. Then
3825 deletes the distdir. Finishes with a command $(POSTOP) which defaults
3826 to a null command. Note: For shdist to work properly a C<shar>
3827 program that can handle directories is mandatory.
3831 Does a $(CI) and a $(RCS_LABEL) on all files in the MANIFEST file.
3835 Customization of the dist targets can be done by specifying a hash
3836 reference to the dist attribute of the WriteMakefile call. The
3837 following parameters are recognized:
3840 COMPRESS ('compress')
3843 RCS_LABEL ('rcs -q -Nv$(VERSION_SYM):')
3851 WriteMakefile( 'dist' => { COMPRESS=>"gzip", SUFFIX=>"gz" })
3856 Andy Dougherty F<E<lt>doughera@lafcol.lafayette.eduE<gt>>, Andreas
3857 KE<ouml>nig F<E<lt>A.Koenig@franz.ww.TU-Berlin.DEE<gt>>, Tim Bunce
3858 F<E<lt>Tim.Bunce@ig.co.ukE<gt>>. VMS support by Charles Bailey
3859 F<E<lt>bailey@HMIVAX.HUMGEN.UPENN.EDUE<gt>>. Contact the makemaker
3860 mailing list C<mailto:makemaker@franz.ww.tu-berlin.de>, if you have any
3863 =head1 MODIFICATION HISTORY
3865 For a more complete documentation see the file Changes in the
3866 MakeMaker distribution package.
3870 See the file Todo in the MakeMaker distribution package.