This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Use $^O; don't use Config unless we need it
[perl5.git] / lib / ExtUtils / MM_Unix.pm
CommitLineData
1e44e2bf
PP
1package ExtUtils::MM_Unix;
2
3use Config;
4use File::Basename;
5use Cwd;
6use DirHandle;
7require File::Find;
8require Exporter;
9require ExtUtils::MakeMaker; # for $Is_OS2 and FileHandle
10require ExtUtils::Liblist;
11require File::Find;
12
13Exporter::import('ExtUtils::MakeMaker',
14 qw( $Verbose &neatvalue));
15
16if ($Is_VMS = $Config::Config{osname} eq 'VMS') {
17 require VMS::Filespec;
18 import VMS::Filespec qw( &vmsify );
19}
20
21$Is_OS2 = $ExtUtils::MakeMaker::Is_OS2;
22
23=head1 NAME
24
25ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
26
27=head1 SYNOPSIS
28
29C<require ExtUtils::MM_Unix;>
30
31=head1 DESCRIPTION
32
33The methods provided by this package are designed to be used in
34conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
35Makefile, it creates one or more objects that inherit their methods
36from a package C<MM>. MM itself doesn't provide any methods, but it
37ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
38specific packages take the responsibility for all the methods provided
39by MM_Unix. We are trying to reduce the number of the necessary
40overrides by defining rather primitive operations within
41ExtUtils::MM_Unix.
42
43If you are going to write a platform specific MM package, please try
44to limit the necessary overrides to primitiv methods, and if it is not
45possible to do so, let's work it out how to achieve that gain.
46
47=head1 METHODS
48
49The following description of methods is still under
50development. Please refer to the code for not suitably documented
51sections and complain loudly to the makemaker mailing list.
52
53=head2 Preloaded methods
54
55=over 2
56
57=item catdir
58
59Concatenate two or more directory names to form a complete path ending
60with a directory
61
62=cut
63
64# ';
65
66sub catdir {
67 shift;
a5f75d66 68 my $result = join('/',@_);
1e44e2bf
PP
69 $result =~ s:/\./:/:g;
70 $result =~ s:/+:/:g;
71 $result;
72}
73
74=item catfile
75
76Concatenate two or more directory names and a filename to form a
77complete path ending with a filename
78
79=cut
80
81sub catfile {
82 shift;
83 my $result = join('/',@_);
84 $result =~ s:/\./:/:g;
85 $result =~ s:/+:/:g;
86 $result;
87}
88
89=item nicetext
90
91misnamed method (will have to be changed). The MM_Unix method just
92returns the argument without further processing.
93
94On VMS used to insure that colons marking targets are preceded by
95space - most Unix Makes don't need this, but it's necessary under VMS
96to distinguish the target delimiter from a colon appearing as part of
97a filespec.
98
99=cut
100
101sub nicetext {
102 my($self,$text) = @_;
103 unless (ref $self){
104 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
105 $self = $ExtUtils::MakeMaker::Parent[-1];
106 }
107 $text;
108}
109
110=item libscan
111
112Takes a path to a file that is found by init_dirscan and returns false
113if we don't want to include this file in the library. Mainly used to
114exclude RCS, CVS, and SCCS directories from installation.
115
116=cut
117
118# ';
119
120sub libscan {
121 my($self,$path) = @_;
122 return '' if $path =~ m:/(RCS|CVS|SCCS)/: ;
123 $path;
124}
125
126=item exescan
127
128Deprecated method. Use libscan instead.
129
130=cut
131
132sub exescan {
133 my($self,$path) = @_;
134 $path;
135}
136
137=item lsdir
138
139Takes as arguments a directory name and a regular expression. Returns
140all entries in the directory that match the regular expression.
141
142=cut
143
144sub lsdir {
145 my($self) = shift;
146 my($dir, $regex) = @_;
147 my(@ls);
148 my $dh = new DirHandle;
149 $dh->open($dir || ".") or return ();
150 @ls = $dh->read;
151 $dh->close;
152 @ls = grep(/$regex/, @ls) if $regex;
153 @ls;
154}
155
156=item path
157
158Takes no argument, returns the environment variable PATH as an array.
159
160=cut
161
162sub path {
163 my($self) = @_;
164 my $path_sep = $Is_OS2 ? ";" : $Is_VMS ? "/" : ":";
165 my $path = $ENV{PATH};
166 $path =~ s:\\:/:g if $Is_OS2;
167 my @path = split $path_sep, $path;
168}
169
170=item replace_manpage_separator
171
172Takes the name of a package, which may be a nested package, in the
173form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
174
175=cut
176
177sub replace_manpage_separator {
178 my($self,$man) = @_;
179 $man =~ s,/+,::,g;
180 $man;
181}
182
183=item file_name_is_absolute
184
185Takes as argument a path and returns true, it it is an absolute path.
186
187=cut
188
189sub file_name_is_absolute {
190 my($self,$file) = @_;
191 $file =~ m:^/: ;
192}
193
194=item prefixify
195
196Check a path variable in $self from %Config, if it contains a prefix,
197and replace it with another one.
198
199Takes as arguments an attribute name, a search prefix and a
200replacement prefix. Changes the attribute in the object.
201
202=cut
203
204sub prefixify {
205 my($self,$var,$sprefix,$rprefix) = @_;
206 $self->{uc $var} ||= $Config{lc $var};
207 $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
208 $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
209}
210
211=item maybe_command_in_dirs
212
213method under development. Not yet used. Ask Ilya :-)
214
215=cut
216
217sub maybe_command_in_dirs { # $ver is optional argument if looking for perl
218# Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
219 my($self, $names, $dirs, $trace, $ver) = @_;
220 my($name, $dir);
221 foreach $dir (@$dirs){
222 next unless defined $dir; # $self->{PERL_SRC} may be undefined
223 foreach $name (@$names){
224 my($abs,$tryabs);
225 if ($self->file_name_is_absolute($name)) {
226 $abs = $name;
227 } elsif ($name =~ m|/|) {
228 $abs = $self->catfile(".", $name); # not absolute
229 } else {
230 $abs = $self->catfile($dir, $name);
231 }
232 print "Checking $abs for $name\n" if ($trace >= 2);
233 next unless $tryabs = $self->maybe_command($abs);
234 print "Substituting $tryabs instead of $abs\n"
235 if ($trace >= 2 and $tryabs ne $abs);
236 $abs = $tryabs;
237 if (defined $ver) {
238 print "Executing $abs\n" if ($trace >= 2);
239 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
240 print "Using PERL=$abs\n" if $trace;
241 return $abs;
242 }
243 } else { # Do not look for perl
244 return $abs;
245 }
246 }
247 }
248}
249
250=item maybe_command
251
252Returns true, if the argument is likely to be a command.
253
254=cut
255
256sub maybe_command {
257 my($self,$file) = @_;
258 return $file if -x $file && ! -d $file;
259 return;
260}
261
262=item perl_script
263
264Returns true, if we the argument is likely to be a perl script. On
265MM_Unix this is true for any ordinary, readable file.
266
267=cut
268
269sub perl_script {
270 my($self,$file) = @_;
271 return 1 if -r $file && ! -d $file;
272 return;
273}
274
275# use SelfLoader;
276# sub ExtUtils::MM_Unix::guess_name ;
277# sub ExtUtils::MM_Unix::init_main ;
278# sub ExtUtils::MM_Unix::init_dirscan ;
279# sub ExtUtils::MM_Unix::init_others ;
280# sub ExtUtils::MM_Unix::find_perl ;
281# sub ExtUtils::MM_Unix::post_initialize ;
282# sub ExtUtils::MM_Unix::const_config ;
283# sub ExtUtils::MM_Unix::constants ;
284# sub ExtUtils::MM_Unix::const_loadlibs ;
285# sub ExtUtils::MM_Unix::const_cccmd ;
286# sub ExtUtils::MM_Unix::tool_autosplit ;
287# sub ExtUtils::MM_Unix::tool_xsubpp ;
288# sub ExtUtils::MM_Unix::xsubpp_version ;
289# sub ExtUtils::MM_Unix::tools_other ;
290# sub ExtUtils::MM_Unix::dist ;
291# sub ExtUtils::MM_Unix::macro ;
292# sub ExtUtils::MM_Unix::depend ;
293# sub ExtUtils::MM_Unix::post_constants ;
294# sub ExtUtils::MM_Unix::pasthru ;
295# sub ExtUtils::MM_Unix::c_o ;
296# sub ExtUtils::MM_Unix::xs_c ;
297# sub ExtUtils::MM_Unix::xs_o ;
298# sub ExtUtils::MM_Unix::top_targets ;
299# sub ExtUtils::MM_Unix::linkext ;
300# sub ExtUtils::MM_Unix::dlsyms ;
301# sub ExtUtils::MM_Unix::dynamic ;
302# sub ExtUtils::MM_Unix::dynamic_bs ;
303# sub ExtUtils::MM_Unix::dynamic_lib ;
304# sub ExtUtils::MM_Unix::static ;
305# sub ExtUtils::MM_Unix::static_lib ;
306# sub ExtUtils::MM_Unix::installpm ;
307# sub ExtUtils::MM_Unix::installpm_x ;
308# sub ExtUtils::MM_Unix::manifypods ;
309# sub ExtUtils::MM_Unix::processPL ;
310# sub ExtUtils::MM_Unix::installbin ;
311# sub ExtUtils::MM_Unix::subdirs ;
312# sub ExtUtils::MM_Unix::subdir_x ;
313# sub ExtUtils::MM_Unix::clean ;
314# sub ExtUtils::MM_Unix::realclean ;
315# sub ExtUtils::MM_Unix::dist_basics ;
316# sub ExtUtils::MM_Unix::dist_core ;
317# sub ExtUtils::MM_Unix::dist_dir ;
318# sub ExtUtils::MM_Unix::dist_test ;
319# sub ExtUtils::MM_Unix::dist_ci ;
320# sub ExtUtils::MM_Unix::install ;
321# sub ExtUtils::MM_Unix::force ;
322# sub ExtUtils::MM_Unix::perldepend ;
323# sub ExtUtils::MM_Unix::makefile ;
324# sub ExtUtils::MM_Unix::staticmake ;
325# sub ExtUtils::MM_Unix::test ;
326# sub ExtUtils::MM_Unix::test_via_harness ;
327# sub ExtUtils::MM_Unix::test_via_script ;
328# sub ExtUtils::MM_Unix::postamble ;
329# sub ExtUtils::MM_Unix::makeaperl ;
330# sub ExtUtils::MM_Unix::extliblist ;
331# sub ExtUtils::MM_Unix::dir_target ;
332# sub ExtUtils::MM_Unix::needs_linking ;
333# sub ExtUtils::MM_Unix::has_link_code ;
334# sub ExtUtils::MM_Unix::writedoc ;
335#
336# 1;
337#
338# __DATA__
339
340# Without SelfLoader we need
3411;
342
343=head2 SelfLoaded methods
344
345=item guess_name
346
347Guess the name of this package by examining the working directory's
348name. MakeMaker calls this only if the developer has not supplied a
349NAME attribute.
350
351=cut
352
353# ';
354
355sub guess_name {
356 my($self) = @_;
357 my $name = fastcwd();
358 $name =~ s:.*/:: unless ($name =~ s:^.*/ext/::);
359 $name =~ s#/#::#g;
360 $name =~ s#[\-_][\d.\-]+$##; # this is new with MM 5.00
361 $name;
362}
363
364=item init_main
365
366
367
368=cut
369
370sub init_main {
371 my($self) = @_;
372 unless (ref $self){
373 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
374 $self = $ExtUtils::MakeMaker::Parent[-1];
375 }
376
377 # --- Initialize Module Name and Paths
378
379 # NAME = The perl module name for this extension (eg DBD::Oracle).
380 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
381 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
382 # ROOTEXT = Directory part of FULLEXT with leading /.
383 ($self->{FULLEXT} =
384 $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
385
386 # Copied from DynaLoader:
387
388 my(@modparts) = split(/::/,$self->{NAME});
389 my($modfname) = $modparts[-1];
390
391 # Some systems have restrictions on files names for DLL's etc.
392 # mod2fname returns appropriate file base name (typically truncated)
393 # It may also edit @modparts if required.
394 if (defined &DynaLoader::mod2fname) {
395 $modfname = &DynaLoader::mod2fname(\@modparts);
396 } elsif ($Is_OS2) { # Need manual correction if run with miniperl:-(
397 $modfname = substr($modfname, 0, 7) . '_';
398 }
399
400
401 ($self->{BASEEXT} =
402 $self->{NAME}) =~ s!.*::!! ; #eg. Socket
403
404 if (defined &DynaLoader::mod2fname or $Is_OS2) {
405 # As of 5.001m, dl_os2 appends '_'
406 $self->{DLBASE} = $modfname; #eg. Socket_
407 } else {
408 $self->{DLBASE} = '$(BASEEXT)';
409 }
410
411 ($self->{ROOTEXT} =
412 $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ; #eg. /BSD/Foo
413
414 $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
415
416
417 # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
418
419 # *Real* information: where did we get these two from? ...
420 my $inc_config_dir = dirname($INC{'Config.pm'});
421 my $inc_carp_dir = dirname($INC{'Carp.pm'});
422
423 unless ($self->{PERL_SRC}){
424 my($dir);
425 foreach $dir (qw(.. ../.. ../../..)){
426 if ( -f "$dir/config.sh"
427 && -f "$dir/perl.h"
428 && -f "$dir/lib/Exporter.pm") {
429 $self->{PERL_SRC}=$dir ;
430 last;
431 }
432 }
433 }
434 if ($self->{PERL_SRC}){
435 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib");
436 $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
437 $self->{PERL_INC} = $self->{PERL_SRC};
438 # catch a situation that has occurred a few times in the past:
439 warn <<EOM unless -s "$self->{PERL_SRC}/cflags";
440You cannot build extensions below the perl source tree after executing
441a 'make clean' in the perl source tree.
442
443To rebuild extensions distributed with the perl source you should
444simply Configure (to include those extensions) and then build perl as
445normal. After installing perl the source tree can be deleted. It is
446not needed for building extensions by running 'perl Makefile.PL'
447usually without extra arguments.
448
449It is recommended that you unpack and build additional extensions away
450from the perl source tree.
451EOM
452 } else {
453 # we should also consider $ENV{PERL5LIB} here
454 $self->{PERL_LIB} ||= $Config::Config{privlibexp};
455 $self->{PERL_ARCHLIB} ||= $Config::Config{archlibexp};
456 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
457 my $perl_h;
458 die <<EOM unless (-f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h")));
459Error: Unable to locate installed Perl libraries or Perl source code.
460
461It is recommended that you install perl in a standard location before
462building extensions. You can say:
463
464 $^X Makefile.PL PERL_SRC=/path/to/perl/source/directory
465
466if you have not yet installed perl but still want to build this
467extension now.
468(You get this message, because MakeMaker could not find "$perl_h")
469EOM
470
471# print STDOUT "Using header files found in $self->{PERL_INC}\n"
472# if $Verbose && $self->needs_linking();
473
474 }
475
476 # We get SITELIBEXP and SITEARCHEXP directly via
477 # Get_from_Config. When we are running standard modules, these
478 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
479 # set it to "site". I prefer that INSTALLDIRS be set from outside
480 # MakeMaker.
481 $self->{INSTALLDIRS} ||= "site";
482
483 # INST_LIB typically pre-set if building an extension after
484 # perl has been built and installed. Setting INST_LIB allows
485 # you to build directly into, say $Config::Config{privlibexp}.
486 unless ($self->{INST_LIB}){
487
488
489 ##### XXXXX We have to change this nonsense
490
491 if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
492 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
493 } else {
494 $self->{INST_LIB} = $self->catdir(".","blib","lib");
495 }
496 }
497 $self->{INST_ARCHLIB} ||= $self->catdir(".","blib","arch");
498 $self->{INST_EXE} ||= $self->catdir('.','blib','bin');
499
500 # The user who requests an installation directory explicitly
501 # should not have to tell us a architecture installation directory
502 # as well We look if a directory exists that is named after the
503 # architecture. If not we take it as a sign that it should be the
504 # same as the requested installation directory. Otherwise we take
505 # the found one.
506 # We do the same thing twice: for privlib/archlib and for sitelib/sitearch
507 my($libpair);
508 for $libpair ({l=>"privlib", a=>"archlib"}, {l=>"sitelib", a=>"sitearch"}) {
509 my $lib = "install$libpair->{l}";
510 my $Lib = uc $lib;
511 my $Arch = uc "install$libpair->{a}";
512 if( $self->{$Lib} && ! $self->{$Arch} ){
513 my($ilib) = $Config{$lib};
514 $ilib = VMS::Filespec::unixify($ilib) if $Is_VMS;
515
516 $self->prefixify($Arch,$ilib,$self->{$Lib});
517
518 unless (-d $self->{$Arch}) {
519 print STDOUT "Directory $self->{$Arch} not found, thusly\n" if $Verbose;
520 $self->{$Arch} = $self->{$Lib};
521 }
522 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
523 }
524 }
525
526 # we have to look at the relation between $Config{prefix} and the
527 # requested values. We're going to set the $Config{prefix} part of
528 # all the installation path variables to literally $(PREFIX), so
529 # the user can still say make PREFIX=foo
530 my($prefix) = $Config{'prefix'};
531 $prefix = VMS::Filespec::unixify($prefix) if $Is_VMS;
532 unless ($self->{PREFIX}){
533 $self->{PREFIX} = $prefix;
534 }
535 my($install_variable);
536 for $install_variable (qw/INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN INSTALLMAN1DIR
537 INSTALLMAN3DIR INSTALLSITELIB INSTALLSITEARCH/) {
538 $self->prefixify($install_variable,$prefix,q[$(PREFIX)]);
539 }
540
541
542 # Now we head at the manpages. Maybe they DO NOT want manpages
543 # installed
544 $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
545 unless defined $self->{INSTALLMAN1DIR};
546 unless (defined $self->{INST_MAN1DIR}){
547 if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
548 $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
549 } else {
550 $self->{INST_MAN1DIR} = $self->catdir('.','blib','man1');
551 }
552 }
553 $self->{MAN1EXT} ||= $Config::Config{man1ext};
554
555 $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
556 unless defined $self->{INSTALLMAN3DIR};
557 unless (defined $self->{INST_MAN3DIR}){
558 if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
559 $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
560 } else {
561 $self->{INST_MAN3DIR} = $self->catdir('.','blib','man3');
562 }
563 }
564 $self->{MAN3EXT} ||= $Config::Config{man3ext};
565
566
567 # Get some stuff out of %Config if we haven't yet done so
568 print STDOUT "CONFIG must be an array ref\n"
569 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
570 $self->{CONFIG} = [] unless (ref $self->{CONFIG});
571 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
572 push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
573 my(%once_only,$m);
574 foreach $m (@{$self->{CONFIG}}){
575 next if $once_only{$m};
576 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
577 unless exists $Config::Config{$m};
578 $self->{uc $m} ||= $Config::Config{$m};
579 $once_only{$m} = 1;
580 }
581
582# This is too dangerous:
583# if ($Config{osname} eq "next") {
584# $self->{AR} = "libtool";
585# $self->{AR_STATIC_ARGS} = "-o";
586# }
587# But I leave it as a placeholder
588
589 $self->{AR_STATIC_ARGS} ||= "cr";
590
591 # These should never be needed
592 $self->{LD} ||= 'ld';
593 $self->{OBJ_EXT} ||= '.o';
594 $self->{LIB_EXT} ||= '.a';
595
596 $self->{MAP_TARGET} ||= "perl";
597
598 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
599
600 # make a simple check if we find Exporter
601 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
602 (Exporter.pm not found)"
603 unless (-f $self->catfile("$self->{PERL_LIB}","Exporter.pm"));
604
605 # Determine VERSION and VERSION_FROM
606 ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
607 if ($self->{VERSION_FROM}){
608 my $fh = new FileHandle;
609 $fh->open($self->{VERSION_FROM}) or die "Could not open '$self->{VERSION_FROM}' (attribute VERSION_FROM): $!";
610 while (<$fh>) {
611 chop;
612 next unless /\$([\w:]*\bVERSION)\b.*=/;
613 local $ExtUtils::MakeMaker::module_version_variable = $1;
614 my($eval) = "$_;";
615 eval $eval;
616 die "Could not eval '$eval': $@" if $@;
617 if ($self->{VERSION} = $ {$ExtUtils::MakeMaker::module_version_variable}){
618 print "$self->{NAME} VERSION is $self->{VERSION} (from $self->{VERSION_FROM})\n" if $Verbose;
619 } else {
620 # XXX this should probably croak
621 print "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n";
622 }
623 last;
624 }
625 close $fh;
626 }
627
628 # if your FOO.pm says
629 # $VERSION = substr(q$Revision: 1.4 $, 10);
630 # then MM says something like
631 # -DXS_VERSION=\"n.nn \"
632 if ($self->{VERSION}) {
633 $self->{VERSION} =~ s/^\s+//;
634 $self->{VERSION} =~ s/\s+$//;
635 }
636
637 $self->{VERSION} = "0.10" unless $self->{VERSION};
638 ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
639
640
641 # Graham Barr and Paul Marquess had some ideas how to ensure
642 # version compatibility between the *.pm file and the
643 # corresponding *.xs file. The bottomline was, that we need an
644 # XS_VERSION macro that defaults to VERSION:
645 $self->{XS_VERSION} ||= $self->{VERSION};
646
647 # --- Initialize Perl Binary Locations
648
649 # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
650 # will be working versions of perl 5. miniperl has priority over perl
651 # for PERL to ensure that $(PERL) is usable while building ./ext/*
652 my ($component,@defpath);
653 foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
654 push @defpath, $component if defined $component;
655 }
656 $self->{PERL} =
657 $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
658 \@defpath, $Verbose ) unless ($self->{PERL});
659 # don't check if perl is executable, maybe they have decided to
660 # supply switches with perl
661
662 # Define 'FULLPERL' to be a non-miniperl (used in test: target)
663 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
664 unless ($self->{FULLPERL});
665}
666
667=item init_dirscan
668
669
670
671=cut
672
673sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
674 my($self) = @_;
675 unless (ref $self){
676 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
677 $self = $ExtUtils::MakeMaker::Parent[-1];
678 }
679 my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
680 local(%pm); #the sub in find() has to see this hash
681 $ignore{'test.pl'} = 1;
682 $ignore{'makefile.pl'} = 1 if $Is_VMS;
683 foreach $name ($self->lsdir(".")){
684 next if ($name =~ /^\./ or $ignore{$name});
685 next unless $self->libscan($name);
686 if (-d $name){
687 $dir{$name} = $name if (-f "$name/Makefile.PL");
688 } elsif ($name =~ /\.xs$/){
689 my($c); ($c = $name) =~ s/\.xs$/.c/;
690 $xs{$name} = $c;
691 $c{$c} = 1;
a5f75d66 692 } elsif ($name =~ /\.c(pp|xx|c)?$/i){ # .c .C .cpp .cxx .cc
1e44e2bf
PP
693 $c{$name} = 1
694 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
695 } elsif ($name =~ /\.h$/i){
696 $h{$name} = 1;
697 } elsif ($name =~ /\.(p[ml]|pod)$/){
698 $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
699 } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
700 ($pl_files{$name} = $name) =~ s/\.PL$// ;
701 } elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
702 $name ne 'test.pl') { # case-insensitive filesystem
703 ($pl_files{$name} = $name) =~ s/\.pl$// ;
704 }
705 }
706
707 # Some larger extensions often wish to install a number of *.pm/pl
708 # files into the library in various locations.
709
710 # The attribute PMLIBDIRS holds an array reference which lists
711 # subdirectories which we should search for library files to
712 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
713 # recursively search through the named directories (skipping any
714 # which don't exist or contain Makefile.PL files).
715
716 # For each *.pm or *.pl file found $self->libscan() is called with
717 # the default installation path in $_[1]. The return value of
718 # libscan defines the actual installation location. The default
719 # libscan function simply returns the path. The file is skipped
720 # if libscan returns false.
721
722 # The default installation location passed to libscan in $_[1] is:
723 #
724 # ./*.pm => $(INST_LIBDIR)/*.pm
725 # ./xyz/... => $(INST_LIBDIR)/xyz/...
726 # ./lib/... => $(INST_LIB)/...
727 #
728 # In this way the 'lib' directory is seen as the root of the actual
729 # perl library whereas the others are relative to INST_LIBDIR
730 # (which includes ROOTEXT). This is a subtle distinction but one
731 # that's important for nested modules.
732
733 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
734 unless $self->{PMLIBDIRS};
735
736 #only existing directories that aren't in $dir are allowed
737
738 # Avoid $_ wherever possible:
739 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
740 my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
741 my ($pmlibdir);
742 @{$self->{PMLIBDIRS}} = ();
743 foreach $pmlibdir (@pmlibdirs) {
744 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
745 }
746
747 if (@{$self->{PMLIBDIRS}}){
748 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
749 if ($Verbose >= 2);
750 File::Find::find(sub {
751 if (-d $_){
752 if ($_ eq "CVS" || $_ eq "RCS"){
753 $File::Find::prune = 1;
754 }
755 return;
756 }
757 my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
758 my($striplibpath,$striplibname);
759 $prefix = '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:);
760 ($striplibname,$striplibpath) = fileparse($striplibpath);
761 my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
762 local($_) = $inst; # for backwards compatibility
763 $inst = $self->libscan($inst);
764 print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
765 return unless $inst;
766 $pm{$path} = $inst;
767 }, @{$self->{PMLIBDIRS}});
768 }
769
770 $self->{DIR} = [sort keys %dir] unless $self->{DIR};
771 $self->{XS} = \%xs unless $self->{XS};
772 $self->{PM} = \%pm unless $self->{PM};
773 $self->{C} = [sort keys %c] unless $self->{C};
774 my(@o_files) = @{$self->{C}};
a5f75d66 775 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
1e44e2bf
PP
776 $self->{H} = [sort keys %h] unless $self->{H};
777 $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
778
779 # Set up names of manual pages to generate from pods
780 if ($self->{MAN1PODS}) {
781 } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
782 $self->{MAN1PODS} = {};
783 } else {
784 my %manifypods = ();
785 if ( exists $self->{EXE_FILES} ) {
786 foreach $name (@{$self->{EXE_FILES}}) {
787 my $fh = new FileHandle;
788 my($ispod)=0;
789 # one day test, if $/ can be set to '' safely (is the bug fixed that was in 5.001m?)
790 if ($fh->open("<$name")) {
791 my $testpodline;
792 while ($testpodline = <$fh>) {
793 if($testpodline =~ /^=head1\s+\w+/) {
794 $ispod=1;
795 last;
796 }
797 }
798 $fh->close;
799 } else {
800 # If it doesn't exist yet, we assume, it has pods in it
801 $ispod = 1;
802 }
803 if( $ispod ) {
804 $manifypods{$name} = $self->catfile('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
805 }
806 }
807 }
808 $self->{MAN1PODS} = \%manifypods;
809 }
810 if ($self->{MAN3PODS}) {
811 } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
812 $self->{MAN3PODS} = {};
813 } else {
814 my %manifypods = (); # we collect the keys first, i.e. the files
815 # we have to convert to pod
816 foreach $name (keys %{$self->{PM}}) {
817 if ($name =~ /\.pod$/ ) {
818 $manifypods{$name} = $self->{PM}{$name};
819 } elsif ($name =~ /\.p[ml]$/ ) {
820 my $fh = new FileHandle;
821 my($ispod)=0;
822 $fh->open("<$name");
823 my $testpodline;
824 while ($testpodline = <$fh>) {
825 if($testpodline =~ /^=head1\s+\w+/) {
826 $ispod=1;
827 last;
828 }
829 #Speculation on the future (K.A., not A.K. :)
830 #if(/^=don't\S+install/) { $ispod=0; last}
831 }
832 $fh->close;
833
834 if( $ispod ) {
835 $manifypods{$name} = $self->{PM}{$name};
836 }
837 }
838 }
839
840 # Remove "Configure.pm" and similar, if it's not the only pod listed
841 # To force inclusion, just name it "Configure.pod", or override MAN3PODS
842 foreach $name (keys %manifypods) {
843 if ($name =~ /(config|setup).*\.pm/i) {
844 delete $manifypods{$name};
845 next;
846 }
847 my($manpagename) = $name;
848 unless ($manpagename =~ s!^(\W*)lib\W!$1!) {
849 $manpagename = $self->catfile($self->{ROOTEXT},$manpagename);
850 }
851 $manpagename =~ s/\.p(od|m|l)$//;
852 # Strip leading slashes
853 $manpagename =~ s!^/+!!;
854 # Turn other slashes into colons
855# $manpagename =~ s,/+,::,g;
856 $manpagename = $self->replace_manpage_separator($manpagename);
857 $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
858 }
859 $self->{MAN3PODS} = \%manifypods;
860 }
861}
862
863=item init_others
864
865
866
867=cut
868
869sub init_others { # --- Initialize Other Attributes
870 my($self) = shift;
871 unless (ref $self){
872 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
873 $self = $ExtUtils::MakeMaker::Parent[-1];
874 }
875
876 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
877 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
878 # undefined. In any case we turn it into an anon array:
879
880 # May check $Config{libs} too, thus not empty.
881 $self->{LIBS}=[''] unless $self->{LIBS};
882
883 $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq SCALAR;
884 $self->{LD_RUN_PATH} = "";
885 my($libs);
886 foreach $libs ( @{$self->{LIBS}} ){
887 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
888 my(@libs) = $self->extliblist($libs);
889 if ($libs[0] or $libs[1] or $libs[2]){
890 # LD_RUN_PATH now computed by ExtUtils::Liblist
891 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
892 last;
893 }
894 }
895
896 unless ( $self->{OBJECT} ){
897 # init_dirscan should have found out, if we have C files
898 $self->{OBJECT} = "";
899 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
900 }
901 $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
902 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
903 $self->{PERLMAINCC} ||= '$(CC)';
904 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
905
906 # Sanity check: don't define LINKTYPE = dynamic if we're skipping
907 # the 'dynamic' section of MM. We don't have this problem with
908 # 'static', since we either must use it (%Config says we can't
909 # use dynamic loading) or the caller asked for it explicitly.
910 if (!$self->{LINKTYPE}) {
911 $self->{LINKTYPE} = grep(/dynamic/,@{$self->{SKIP} || []})
912 ? 'static'
913 : ($Config::Config{usedl} ? 'dynamic' : 'static');
914 };
915
916 # These get overridden for VMS and maybe some other systems
917 $self->{NOOP} ||= "";
918 $self->{FIRST_MAKEFILE} ||= "Makefile";
919 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
920 $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
921 $self->{NOECHO} = '@' unless defined $self->{NOECHO};
922 $self->{RM_F} ||= "rm -f";
923 $self->{RM_RF} ||= "rm -rf";
924 $self->{TOUCH} ||= "touch";
925 $self->{CP} ||= "cp";
926 $self->{MV} ||= "mv";
927 $self->{CHMOD} ||= "chmod";
928 $self->{UMASK_NULL} ||= "umask 0";
929}
930
931=item find_perl
932
933
934
935=cut
936
937sub find_perl {
938 my($self, $ver, $names, $dirs, $trace) = @_;
939 unless (ref $self){
940 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
941 $self = $ExtUtils::MakeMaker::Parent[-1];
942 }
943 my($name, $dir);
944 if ($trace >= 2){
945 print "Looking for perl $ver by these names:
946@$names
947in these dirs:
948@$dirs
949";
950 }
951 foreach $dir (@$dirs){
952 next unless defined $dir; # $self->{PERL_SRC} may be undefined
953 foreach $name (@$names){
954 my $abs;
955 if ($self->file_name_is_absolute($name)) {
956 $abs = $name;
957 } elsif (($name =~ m|/|) && ($name !~ m|^\.{1,2}/|)) {
958 # name is a path that does not begin with dot or dotdot
959 $abs = $self->catfile(".", $name);
960 } else {
961 $abs = $self->catfile($dir, $name);
962 }
963 print "Checking $abs\n" if ($trace >= 2);
964 next unless $self->maybe_command($abs);
965 print "Executing $abs\n" if ($trace >= 2);
966 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
967 print "Using PERL=$abs\n" if $trace;
968 return $abs;
969 }
970 }
971 }
972 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
973 0; # false and not empty
974}
975
976=head2 Methods to actually produce chunks of text for the Makefile
977
978The methods here are called in the order specified by
979@ExtUtils::MakeMaker::MM_Sections. This manpage reflects the order as
980well as possible. Some methods call each other, so in doubt refer to
981the code.
982
983=item post_initialize
984
985Returns an ampty string per default. Used in Makefile.PLs to add some
986chunk of text to the Makefile after the object is initialized.
987
988=cut
989
990sub post_initialize {
991 my($self) = shift;
992 unless (ref $self){
993 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
994 $self = $ExtUtils::MakeMaker::Parent[-1];
995 }
996 "";
997}
998
999=item const_config
1000
1001
1002
1003=cut
1004
1005sub const_config {
1006# --- Constants Sections ---
1007
1008 my($self) = shift;
1009 unless (ref $self){
1010 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1011 $self = $ExtUtils::MakeMaker::Parent[-1];
1012 }
1013 my(@m,$m);
1014 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
1015 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
1016 my(%once_only);
1017 foreach $m (@{$self->{CONFIG}}){
a5f75d66
AD
1018 # SITE*EXP macros are defined in &constants; avoid duplicates here
1019 next if $once_only{$m} or $m eq 'SITELIBEXP' or $m eq 'SITEARCHEXP';
1e44e2bf
PP
1020 push @m, "\U$m\E = ".$self->{uc $m}."\n";
1021 $once_only{$m} = 1;
1022 }
1023 join('', @m);
1024}
1025
1026=item constants
1027
1028
1029
1030=cut
1031
1032sub constants {
1033 my($self) = @_;
1034 unless (ref $self){
1035 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1036 $self = $ExtUtils::MakeMaker::Parent[-1];
1037 }
1038 my(@m,$tmp);
1039
1040 for $tmp (qw/
1041 AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION VERSION_SYM XS_VERSION
1042 INST_LIB INST_ARCHLIB INST_EXE PREFIX INSTALLDIRS INSTALLPRIVLIB
1043 INSTALLARCHLIB INSTALLSITELIB INSTALLSITEARCH INSTALLBIN PERL_LIB
1044 PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
1045 FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC PERL_INC PERL FULLPERL
1046 / ) {
1047 next unless defined $self->{$tmp};
1048 push @m, "$tmp = $self->{$tmp}\n";
1049 }
1050
1051 push @m, qq{
1052VERSION_MACRO = VERSION
1053DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
1054XS_VERSION_MACRO = XS_VERSION
1055XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
1056};
1057
1058 push @m, qq{
1059MAKEMAKER = \$(PERL_LIB)/ExtUtils/MakeMaker.pm
1060MM_VERSION = $ExtUtils::MakeMaker::VERSION
1061MM_REVISION = $Revision
1062};
1063
1064 push @m, q{
1065# FULLEXT = Pathname for extension directory (eg DBD/Oracle).
1066# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
1067# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
1068# DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
1069};
1070
1071 for $tmp (qw/
1072 FULLEXT BASEEXT ROOTEXT DLBASE VERSION_FROM INC DEFINE OBJECT OBJECT
1073 LDFROM LINKTYPE
1074 / ) {
1075 next unless defined $self->{$tmp};
1076 push @m, "$tmp = $self->{$tmp}\n";
1077 }
1078
1079 push @m, "
1080# Handy lists of source code files:
1081XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
1082C_FILES = ".join(" \\\n\t", @{$self->{C}})."
1083O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
1084H_FILES = ".join(" \\\n\t", @{$self->{H}})."
1085MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
1086MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
1087";
1088
1089 for $tmp (qw/
1090 INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
1091 /) {
1092 next unless defined $self->{$tmp};
1093 push @m, "$tmp = $self->{$tmp}\n";
1094 }
1095
1096 push @m, "
1097# work around a famous dec-osf make(1) feature(?):
1098makemakerdflt: all
1099
a5f75d66 1100.SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
1e44e2bf
PP
1101
1102# Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
1103# some make implementations will delete the Makefile when we rebuild it. Because
1104# we call false(1) when we rebuild it. So make(1) is not completely wrong when it
1105# does so. Our milage may vary.
1106# .PRECIOUS: Makefile # seems to be not necessary anymore
1107
1108.PHONY: all config static dynamic test linkext manifest
1109
1110# Where is the Config information that we are using/depend on
1111CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h \$(VERSION_FROM)
1112";
1113
1114 push @m, '
1115# Where to put things:
1116INST_LIBDIR = $(INST_LIB)$(ROOTEXT)
1117INST_ARCHLIBDIR = $(INST_ARCHLIB)$(ROOTEXT)
1118
1119INST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT)
1120INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
1121';
1122
1123 if ($self->has_link_code()) {
1124 push @m, '
1125INST_STATIC = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
1126INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
1127INST_BOOT = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
1128';
1129 } else {
1130 push @m, '
1131INST_STATIC =
1132INST_DYNAMIC =
1133INST_BOOT =
1134';
1135 }
1136
1137 if ($Is_OS2) {
1138 $tmp = "$self->{BASEEXT}.def";
1139 } else {
1140 $tmp = "";
1141 }
1142 push @m, "
1143EXPORT_LIST = $tmp
1144";
1145
1146 if ($Is_OS2) {
1147 $tmp = "\$(PERL_INC)/libperl.lib";
1148 } else {
1149 $tmp = "";
1150 }
1151 push @m, "
1152PERL_ARCHIVE = $tmp
1153";
1154
1155 push @m, '
1156INST_PM = '.join(" \\\n\t", sort values %{$self->{PM}}).'
1157';
1158
1159 join('',@m);
1160}
1161
1162=item const_loadlibs
1163
1164
1165
1166=cut
1167
1168sub const_loadlibs {
1169 my($self) = shift;
1170 unless (ref $self){
1171 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1172 $self = $ExtUtils::MakeMaker::Parent[-1];
1173 }
1174 return "" unless $self->needs_linking;
1175 # This description can be deleted after ExtUtils::Liblist is in
1176 # the perl dist with pods
1177 "
1178# $self->{NAME} might depend on some other libraries:
1179# (These comments may need revising:)
1180#
1181# Dependent libraries can be linked in one of three ways:
1182#
1183# 1. (For static extensions) by the ld command when the perl binary
1184# is linked with the extension library. See EXTRALIBS below.
1185#
1186# 2. (For dynamic extensions) by the ld command when the shared
1187# object is built/linked. See LDLOADLIBS below.
1188#
1189# 3. (For dynamic extensions) by the DynaLoader when the shared
1190# object is loaded. See BSLOADLIBS below.
1191#
1192# EXTRALIBS = List of libraries that need to be linked with when
1193# linking a perl binary which includes this extension
1194# Only those libraries that actually exist are included.
1195# These are written to a file and used when linking perl.
1196#
1197# LDLOADLIBS = List of those libraries which can or must be linked into
1198# the shared library when created using ld. These may be
1199# static or dynamic libraries.
1200# LD_RUN_PATH is a colon separated list of the directories
1201# in LDLOADLIBS. It is passed as an environment variable to
1202# the process that links the shared library.
1203#
1204# BSLOADLIBS = List of those libraries that are needed but can be
1205# linked in dynamically at run time on this platform.
1206# SunOS/Solaris does not need this because ld records
1207# the information (from LDLOADLIBS) into the object file.
1208# This list is used to create a .bs (bootstrap) file.
1209#
1210EXTRALIBS = $self->{EXTRALIBS}
1211LDLOADLIBS = $self->{LDLOADLIBS}
1212BSLOADLIBS = $self->{BSLOADLIBS}
1213LD_RUN_PATH= $self->{LD_RUN_PATH}
1214";
1215}
1216
1217=item const_cccmd
1218
1219
1220
1221=cut
1222
1223sub const_cccmd {
1224 my($self,$libperl)=@_;
1225 unless (ref $self){
1226 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1227 $self = $ExtUtils::MakeMaker::Parent[-1];
1228 }
1229 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
1230 return '' unless $self->needs_linking();
1231 $libperl or $libperl = $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
1232 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
1233 # This is implemented in the same manner as extliblist,
1234 # e.g., do both and compare results during the transition period.
1235 my($cc,$ccflags,$optimize,$large,$split, $shflags)
1236 = @Config{qw(cc ccflags optimize large split shellflags)};
1237 my($optdebug) = "";
1238
1239 $shflags = '' unless $shflags;
1240 my($prog, $uc, $perltype);
1241
1242 my(%map) = (
1243 D => '-DDEBUGGING',
1244 E => '-DEMBED',
1245 DE => '-DDEBUGGING -DEMBED',
1246 M => '-DEMBED -DMULTIPLICITY',
1247 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
1248 );
1249
1250 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
1251 $uc = uc($1);
1252 } else {
1253 $uc = ""; # avoid warning
1254 }
1255 $perltype = $map{$uc} ? $map{$uc} : "";
1256
1257 if ($uc =~ /^D/) {
1258 $optdebug = "-g";
1259 }
1260
1261
1262 my($name);
1263 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
1264 if ($prog = $Config::Config{$name}) {
1265 # Expand hints for this extension via the shell
1266 print STDOUT "Processing $name hint:\n" if $Verbose;
1267 my(@o)=`cc=\"$cc\"
1268 ccflags=\"$ccflags\"
1269 optimize=\"$optimize\"
1270 perltype=\"$perltype\"
1271 optdebug=\"$optdebug\"
1272 large=\"$large\"
1273 split=\"$split\"
1274 eval '$prog'
1275 echo cc=\$cc
1276 echo ccflags=\$ccflags
1277 echo optimize=\$optimize
1278 echo perltype=\$perltype
1279 echo optdebug=\$optdebug
1280 echo large=\$large
1281 echo split=\$split
1282 `;
1283 my(%cflags,$line);
1284 foreach $line (@o){
1285 chomp $line;
1286 if ($line =~ /(.*?)=\s*(.*)\s*$/){
1287 $cflags{$1} = $2;
1288 print STDOUT " $1 = $2\n" if $Verbose;
1289 } else {
1290 print STDOUT "Unrecognised result from hint: '$line'\n";
1291 }
1292 }
1293 ( $cc,$ccflags,$perltype,$optdebug,$optimize,$large,$split )=@cflags{
1294 qw( cc ccflags perltype optdebug optimize large split)};
1295 }
1296
1297 if ($optdebug) {
1298 $optimize = $optdebug;
1299 }
1300
1301 my($new) = "$cc -c \$(INC) $ccflags $optimize $perltype $large $split";
1302 $new =~ s/^\s+//; $new =~ s/\s+/ /g; $new =~ s/\s+$//;
1303
1304 my($cccmd) = $new;
1305 $cccmd =~ s/^\s*\Q$Config::Config{cc}\E\s/\$(CC) /;
1306 $cccmd .= " \$(DEFINE_VERSION) \$(XS_DEFINE_VERSION)";
1307 $self->{CONST_CCCMD} = "CCCMD = $cccmd\n";
1308}
1309
1310=item tool_autosplit
1311
1312
1313
1314=cut
1315
1316sub tool_autosplit {
1317# --- Tool Sections ---
1318
1319 my($self, %attribs) = @_;
1320 unless (ref $self){
1321 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1322 $self = $ExtUtils::MakeMaker::Parent[-1];
1323 }
1324 my($asl) = "";
1325 $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
1326 q{
1327# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
1328AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
1329};
1330}
1331
1332=item tool_xsubpp
1333
1334
1335
1336=cut
1337
1338sub tool_xsubpp {
1339 my($self) = shift;
1340 unless (ref $self){
1341 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1342 $self = $ExtUtils::MakeMaker::Parent[-1];
1343 }
1344 my($xsdir) = "$self->{PERL_LIB}/ExtUtils";
1345 # drop back to old location if xsubpp is not in new location yet
1346 $xsdir = "$self->{PERL_SRC}/ext" unless (-f "$self->{PERL_LIB}/ExtUtils/xsubpp");
1347 my(@tmdeps) = ('$(XSUBPPDIR)/typemap');
1348 if( $self->{TYPEMAPS} ){
1349 my $typemap;
1350 foreach $typemap (@{$self->{TYPEMAPS}}){
1351 if( ! -f $typemap ){
1352 warn "Typemap $typemap not found.\n";
1353 }
1354 else{
1355 push(@tmdeps, $typemap);
1356 }
1357 }
1358 }
1359 push(@tmdeps, "typemap") if -f "typemap";
1360 my(@tmargs) = map("-typemap $_", @tmdeps);
1361 if( exists $self->{XSOPT} ){
1362 unshift( @tmargs, $self->{XSOPT} );
1363 }
1364
1365 my $xsubpp_version = $self->xsubpp_version("$xsdir/xsubpp");
1366
1367 # What are the correct thresholds for version 1 && 2 Paul?
1368 if ( $xsubpp_version > 1.923 ){
1369 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
1370 } else {
1371 if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
1372 print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
1373 Your version of xsubpp is $xsubpp_version and cannot handle this.
1374 Please upgrade to a more recent version of xsubpp.
1375};
1376 } else {
1377 $self->{XSPROTOARG} = "";
1378 }
1379 }
1380
1381 "
1382XSUBPPDIR = $xsdir
1383XSUBPP = \$(XSUBPPDIR)/xsubpp
1384XSPROTOARG = $self->{XSPROTOARG}
1385XSUBPPDEPS = @tmdeps
1386XSUBPPARGS = @tmargs
1387";
1388};
1389
1390sub xsubpp_version
1391{
1392 my($self,$xsubpp) = @_;
1393 my ($version) ;
1394
1395 # try to figure out the version number of the xsubpp on the system
1396
1397 # first try the -v flag, introduced in 1.921 & 2.000a2
1398
1399 my $command = "$self->{PERL} $xsubpp -v 2>&1";
1400 print "Running $command\n" if $Verbose >= 2;
1401 $version = `$command` ;
1402 warn "Running '$command' exits with status " . ($?>>8) if $?;
1403 chop $version ;
1404
1405 return $1 if $version =~ /^xsubpp version (.*)/ ;
1406
1407 # nope, then try something else
1408
1409 my $counter = '000';
1410 my ($file) = 'temp' ;
1411 $counter++ while -e "$file$counter"; # don't overwrite anything
1412 $file .= $counter;
1413
1414 open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
1415 print F <<EOM ;
1416MODULE = fred PACKAGE = fred
1417
1418int
1419fred(a)
1420 int a;
1421EOM
1422
1423 close F ;
1424
1425 $command = "$self->{PERL} $xsubpp $file 2>&1";
1426 print "Running $command\n" if $Verbose >= 2;
1427 my $text = `$command` ;
1428 warn "Running '$command' exits with status " . ($?>>8) if $?;
1429 unlink $file ;
1430
1431 # gets 1.2 -> 1.92 and 2.000a1
1432 return $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/ ;
1433
1434 # it is either 1.0 or 1.1
1435 return 1.1 if $text =~ /^Warning: ignored semicolon/ ;
1436
1437 # none of the above, so 1.0
1438 return "1.0" ;
1439}
1440
1441=item tools_other
1442
1443
1444
1445=cut
1446
1447sub tools_other {
1448 my($self) = shift;
1449 unless (ref $self){
1450 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1451 $self = $ExtUtils::MakeMaker::Parent[-1];
1452 }
1453 "
1454SHELL = /bin/sh
1455LD = $self->{LD}
1456TOUCH = $self->{TOUCH}
1457CP = $self->{CP}
1458MV = $self->{MV}
1459RM_F = $self->{RM_F}
1460RM_RF = $self->{RM_RF}
1461CHMOD = $self->{CHMOD}
1462UMASK_NULL = $self->{UMASK_NULL}
1463".q{
1464# The following is a portable way to say mkdir -p
1465# To see which directories are created, change the if 0 to if 1
1466MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
1467-e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
1468-e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
1469-e 'mkdir("@p",0777)||die $$! } } exit 0;'
1470
1471# This helps us to minimize the effect of the .exists files A yet
1472# better solution would be to have a stable file in the perl
1473# distribution with a timestamp of zero. But this solution doesn't
1474# need any changes to the core distribution and works with older perls
1475EQUALIZE_TIMESTAMP = $(PERL) -we 'open F, ">$$ARGV[1]"; close F;' \\
1476-e 'utime ((stat("$$ARGV[0]"))[8,9], $$ARGV[1])'
1477
1478# Here we warn users that an old packlist file was found somewhere,
1479# and that they should call some uninstall routine
1480WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
1481-e 'print "WARNING: I have found an old package in\n";' \\
1482-e 'print "\t$$ARGV[0].\n";' \\
1483-e 'print "Please make sure the two installations are not conflicting\n";'
1484
1485MOD_INSTALL = $(PERL) -I$(INST_LIB) -MExtUtils::Install \
1486-e 'install({@ARGV},1);'
1487
1488DOC_INSTALL = $(PERL) -e '$$\="\n\n";print "=head3 ", scalar(localtime), ": C<", shift, ">";' \
1489-e 'print "=over 4";' \
1490-e 'while ($$key = shift and $$val = shift){print "=item *";print "C<$$key: $$val>";}' \
1491-e 'print "=back";'
1492
1493UNINSTALL = $(PERL) -MExtUtils::Install \
1494-e 'uninstall($$ARGV[0],1);'
1495
1496};
1497}
1498
1499=item dist
1500
1501
1502
1503=cut
1504
1505sub dist {
1506 my($self, %attribs) = @_;
1507 unless (ref $self){
1508 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1509 $self = $ExtUtils::MakeMaker::Parent[-1];
1510 }
1511 my(@m);
1512 # VERSION should be sanitised before use as a file name
1513 my($name) = $attribs{NAME} || '$(DISTVNAME)';
1514 my($tar) = $attribs{TAR} || 'tar'; # eg /usr/bin/gnutar
1515 my($tarflags) = $attribs{TARFLAGS} || 'cvf';
1516 my($compress) = $attribs{COMPRESS} || 'compress'; # eg gzip
1517 my($suffix) = $attribs{SUFFIX} || 'Z'; # eg gz
1518 my($shar) = $attribs{SHAR} || 'shar'; # eg "shar --gzip"
1519 my($preop) = $attribs{PREOP} || "$self->{NOECHO}true"; # eg update MANIFEST
1520 my($postop) = $attribs{POSTOP} || "$self->{NOECHO}true"; # eg remove the distdir
1521 my($ci) = $attribs{CI} || 'ci -u';
1522 my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
1523 my($dist_cp) = $attribs{DIST_CP} || 'best';
1524 my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
1525
1526 push @m, "
1527DISTVNAME = \$(DISTNAME)-\$(VERSION)
1528TAR = $tar
1529TARFLAGS = $tarflags
1530COMPRESS = $compress
1531SUFFIX = $suffix
1532SHAR = $shar
1533PREOP = $preop
1534POSTOP = $postop
1535CI = $ci
1536RCS_LABEL = $rcs_label
1537DIST_CP = $dist_cp
1538DIST_DEFAULT = $dist_default
1539";
1540 join "", @m;
1541}
1542
1543=item macro
1544
1545
1546
1547=cut
1548
1549sub macro {
1550 my($self,%attribs) = @_;
1551 unless (ref $self){
1552 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1553 $self = $ExtUtils::MakeMaker::Parent[-1];
1554 }
1555 my(@m,$key,$val);
1556 while (($key,$val) = each %attribs){
1557 push @m, "$key = $val\n";
1558 }
1559 join "", @m;
1560}
1561
1562=item depend
1563
1564
1565
1566=cut
1567
1568sub depend {
1569 my($self,%attribs) = @_;
1570 unless (ref $self){
1571 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1572 $self = $ExtUtils::MakeMaker::Parent[-1];
1573 }
1574 my(@m,$key,$val);
1575 while (($key,$val) = each %attribs){
1576 push @m, "$key: $val\n";
1577 }
1578 join "", @m;
1579}
1580
1581=item post_constants
1582
1583
1584
1585=cut
1586
1587sub post_constants{
1588 my($self) = shift;
1589 unless (ref $self){
1590 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1591 $self = $ExtUtils::MakeMaker::Parent[-1];
1592 }
1593 "";
1594}
1595
1596=item pasthru
1597
1598
1599
1600=cut
1601
1602sub pasthru {
1603 my($self) = shift;
1604 unless (ref $self){
1605 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1606 $self = $ExtUtils::MakeMaker::Parent[-1];
1607 }
1608 my(@m,$key);
1609
1610 my(@pasthru);
1611
1612 foreach $key (qw(INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
1613 INSTALLMAN1DIR INSTALLMAN3DIR LIBPERL_A
1614 LINKTYPE PREFIX INSTALLSITELIB
1615 INSTALLSITEARCH INSTALLDIRS)){
1616 push @pasthru, "$key=\"\$($key)\"";
1617 }
1618
1619 push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
1620 join "", @m;
1621}
1622
1623=item c_o
1624
1625
1626
1627=cut
1628
1629sub c_o {
1630# --- Translation Sections ---
1631
1632 my($self) = shift;
1633 unless (ref $self){
1634 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1635 $self = $ExtUtils::MakeMaker::Parent[-1];
1636 }
1637 return '' unless $self->needs_linking();
1638 my(@m);
1639 push @m, '
1640.c$(OBJ_EXT):
1641 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1642
1643.C$(OBJ_EXT):
1644 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
a5f75d66
AD
1645
1646.cpp$(OBJ_EXT):
1647 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
1648
1649.cxx$(OBJ_EXT):
1650 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
1651
1652.cc$(OBJ_EXT):
1653 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
1e44e2bf
PP
1654';
1655 join "", @m;
1656}
1657
1658=item xs_c
1659
1660
1661
1662=cut
1663
1664sub xs_c {
1665 my($self) = shift;
1666 unless (ref $self){
1667 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1668 $self = $ExtUtils::MakeMaker::Parent[-1];
1669 }
1670 return '' unless $self->needs_linking();
1671 '
1672.xs.c:
1673 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
1674';
1675}
1676
1677=item xs_o
1678
1679
1680
1681=cut
1682
1683sub xs_o { # many makes are too dumb to use xs_c then c_o
1684 my($self) = shift;
1685 unless (ref $self){
1686 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1687 $self = $ExtUtils::MakeMaker::Parent[-1];
1688 }
1689 return '' unless $self->needs_linking();
1690 '
1691.xs$(OBJ_EXT):
1692 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
1693 $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
1694';
1695}
1696
1697=item top_targets
1698
1699
1700
1701=cut
1702
1703sub top_targets {
1704# --- Target Sections ---
1705
1706 my($self) = shift;
1707 unless (ref $self){
1708 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1709 $self = $ExtUtils::MakeMaker::Parent[-1];
1710 }
1711 my(@m);
1712 push @m, '
1713all :: config $(INST_PM) subdirs linkext manifypods
1714
1715subdirs :: $(MYEXTLIB)
1716
1717'.$self->{NOOP}.'
1718
1719config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
1720
1721config :: $(INST_ARCHAUTODIR)/.exists
1722
1723config :: $(INST_AUTODIR)/.exists
1724';
1725
1726 push @m, q{
1727config :: Version_check
1728
1729} unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl");
1730
1731 push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
1732
1733 if (%{$self->{MAN1PODS}}) {
1734 push @m, q[
1735config :: $(INST_MAN1DIR)/.exists
1736
1737];
1738 push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
1739 }
1740 if (%{$self->{MAN3PODS}}) {
1741 push @m, q[
1742config :: $(INST_MAN3DIR)/.exists
1743
1744];
1745 push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
1746 }
1747
1748 push @m, '
1749$(O_FILES): $(H_FILES)
1750' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
1751
1752 push @m, q{
1753help:
1754 perldoc ExtUtils::MakeMaker
1755};
1756
1757 push @m, q{
1758Version_check:
1759 }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
1760 -MExtUtils::MakeMaker=Version_check \
1761 -e 'Version_check("$(MM_VERSION)")'
1762};
1763
1764 join('',@m);
1765}
1766
1767=item linkext
1768
1769
1770
1771=cut
1772
1773sub linkext {
1774 my($self, %attribs) = @_;
1775 unless (ref $self){
1776 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1777 $self = $ExtUtils::MakeMaker::Parent[-1];
1778 }
1779 # LINKTYPE => static or dynamic or ''
1780 my($linktype) = defined $attribs{LINKTYPE} ?
1781 $attribs{LINKTYPE} : '$(LINKTYPE)';
1782 "
1783linkext :: $linktype
1784$self->{NOOP}
1785";
1786}
1787
1788=item dlsyms
1789
1790
1791
1792=cut
1793
1794sub dlsyms {
1795 my($self,%attribs) = @_;
1796 unless (ref $self){
1797 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1798 $self = $ExtUtils::MakeMaker::Parent[-1];
1799 }
1800
1801 return '' unless ($Config::Config{osname} eq 'aix' && $self->needs_linking() );
1802
1803 my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
1804 my($vars) = $attribs{DL_VARS} || $self->{DL_VARS} || [];
1805 my(@m);
1806
1807 push(@m,"
1808dynamic :: $self->{BASEEXT}.exp
1809
1810") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
1811
1812 push(@m,"
1813static :: $self->{BASEEXT}.exp
1814
1815") unless $self->{SKIPHASH}{'static'}; # we avoid a warning if we tick them
1816
1817 push(@m,"
1818$self->{BASEEXT}.exp: Makefile.PL
1819",' $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
1820 Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
1821 neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
1822');
1823
1824 join('',@m);
1825}
1826
1827=item dynamic
1828
1829
1830
1831=cut
1832
1833sub dynamic {
1834# --- Dynamic Loading Sections ---
1835
1836 my($self) = shift;
1837 unless (ref $self){
1838 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1839 $self = $ExtUtils::MakeMaker::Parent[-1];
1840 }
1841 '
1842# $(INST_PM) has been moved to the all: target.
1843# It remains here for awhile to allow for old usage: "make dynamic"
1844dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
1845'.$self->{NOOP}.'
1846';
1847}
1848
1849=item dynamic_bs
1850
1851
1852
1853=cut
1854
1855sub dynamic_bs {
1856 my($self, %attribs) = @_;
1857 unless (ref $self){
1858 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1859 $self = $ExtUtils::MakeMaker::Parent[-1];
1860 }
1861 return '
1862BOOTSTRAP =
1863' unless $self->has_link_code();
1864
1865 return '
1866BOOTSTRAP = '."$self->{BASEEXT}.bs".'
1867
1868# As Mkbootstrap might not write a file (if none is required)
1869# we use touch to prevent make continually trying to remake it.
1870# The DynaLoader only reads a non-empty file.
1871$(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
1872 '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1873 '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
1874 -e \'use ExtUtils::Mkbootstrap;\' \
1875 -e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
1876 '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
1877 $(CHMOD) 644 $@
1878
1879$(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
1880 '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
1881 -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
1882 $(CHMOD) 644 $@
1883';
1884}
1885
1886=item dynamic_lib
1887
1888
1889
1890=cut
1891
1892sub dynamic_lib {
1893 my($self, %attribs) = @_;
1894 unless (ref $self){
1895 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1896 $self = $ExtUtils::MakeMaker::Parent[-1];
1897 }
1898 return '' unless $self->needs_linking(); #might be because of a subdir
1899
1900 return '' unless $self->has_link_code;
1901
1902 my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1903 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1904 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
1905 my($ldfrom) = '$(LDFROM)';
1906 my($osname) = $Config::Config{osname};
1907 $armaybe = 'ar' if ($osname eq 'dec_osf' and $armaybe eq ':');
1908 my(@m);
1909 push(@m,'
1910# This section creates the dynamically loadable $(INST_DYNAMIC)
1911# from $(OBJECT) and possibly $(MYEXTLIB).
1912ARMAYBE = '.$armaybe.'
1913OTHERLDFLAGS = '.$otherldflags.'
1914INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
1915
1916$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
1917');
1918 if ($armaybe ne ':'){
1919 $ldfrom = 'tmp$(LIB_EXT)';
1920 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
1921 push(@m,' $(RANLIB) '."$ldfrom\n");
1922 }
1923 $ldfrom = "-all $ldfrom -none" if ($osname eq 'dec_osf');
1924 push(@m,' LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
1925 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(LDLOADLIBS) $(EXPORT_LIST) $(PERL_ARCHIVE)');
1926 push @m, '
1927 $(CHMOD) 755 $@
1928';
1929
1930 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1931 join('',@m);
1932}
1933
1934=item static
1935
1936
1937
1938=cut
1939
1940sub static {
1941# --- Static Loading Sections ---
1942
1943 my($self) = shift;
1944 unless (ref $self){
1945 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1946 $self = $ExtUtils::MakeMaker::Parent[-1];
1947 }
1948 '
1949# $(INST_PM) has been moved to the all: target.
1950# It remains here for awhile to allow for old usage: "make static"
1951static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
1952'.$self->{NOOP}.'
1953';
1954}
1955
1956=item static_lib
1957
1958
1959
1960=cut
1961
1962sub static_lib {
1963 my($self) = @_;
1964 unless (ref $self){
1965 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1966 $self = $ExtUtils::MakeMaker::Parent[-1];
1967 }
1968# Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
1969# return '' unless $self->needs_linking(); #might be because of a subdir
1970
1971 return '' unless $self->has_link_code;
1972
1973 my(@m);
1974 push(@m, <<'END');
1975$(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
1976END
1977 # If this extension has it's own library (eg SDBM_File)
1978 # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
1979 push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
1980
1981 push @m,
1982q{ $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
1983 }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
1984 $(CHMOD) 755 $@
1985};
1986
1987# Old mechanism - still available:
1988
1989 push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
1990 if $self->{PERL_SRC};
1991
1992 push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1993 join('', "\n",@m);
1994}
1995
1996=item installpm
1997
1998
1999
2000=cut
2001
2002sub installpm {
2003 my($self, %attribs) = @_;
2004 unless (ref $self){
2005 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2006 $self = $ExtUtils::MakeMaker::Parent[-1];
2007 }
2008 # By default .pm files are split into the architecture independent
2009 # library. This is a good thing. If a specific module requires that
2010 # it's .pm files are split into the architecture specific library
2011 # then it should use: installpm => {SPLITLIB=>'$(INST_ARCHLIB)'}
2012 # Note that installperl currently interferes with this (Config.pm)
2013 # User can disable split by saying: installpm => {SPLITLIB=>''}
2014 my($splitlib) = '$(INST_LIB)'; # NOT arch specific by default
2015 $splitlib = $attribs{SPLITLIB} if exists $attribs{SPLITLIB};
2016 my(@m, $dist);
2017 push @m, "inst_pm :: \$(INST_PM)\n\n";
2018 foreach $dist (sort keys %{$self->{PM}}){
2019 my($inst) = $self->{PM}->{$dist};
2020 push(@m, "\n# installpm: $dist => $inst, splitlib=$splitlib\n");
2021 push(@m, $self->installpm_x($dist, $inst, $splitlib));
2022 push(@m, "\n");
2023 }
2024 join('', @m);
2025}
2026
2027=item installpm_x
2028
2029
2030
2031=cut
2032
2033sub installpm_x { # called by installpm per file
2034 my($self, $dist, $inst, $splitlib) = @_;
2035 unless (ref $self){
2036 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2037 $self = $ExtUtils::MakeMaker::Parent[-1];
2038 }
2039 if ($inst =~ m,[:\#],){
2040 warn "Warning: 'make' would have problems processing this file: '$inst', SKIPPED\n";
2041 return '';
2042 }
2043 my($instdir) = $inst =~ m|(.*)/|;
2044 my(@m);
2045 push(@m,"
2046$inst: $dist $self->{MAKEFILE} $instdir/.exists \$(INST_ARCHAUTODIR)/.exists
2047 $self->{NOECHO}$self->{RM_F}".' $@
2048 $(UMASK_NULL) && '."$self->{CP} $dist".' $@
2049');
2050 push(@m, "\t$self->{NOECHO}\$(AUTOSPLITFILE) \$@ $splitlib/auto\n")
2051 if ($splitlib and $inst =~ m/\.pm$/);
2052
2053 push @m, $self->dir_target($instdir);
2054 join('', @m);
2055}
2056
2057=item manifypods
2058
2059
2060
2061=cut
2062
2063sub manifypods {
2064 my($self, %attribs) = @_;
2065 unless (ref $self){
2066 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2067 $self = $ExtUtils::MakeMaker::Parent[-1];
2068 }
2069 return "\nmanifypods :\n" unless %{$self->{MAN3PODS}};
2070 my($dist);
2071 my($pod2man_exe);
2072 if (defined $self->{PERL_SRC}) {
2073 $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2074 } else {
2075 $pod2man_exe = $self->catfile($Config{bin},'pod2man');
2076 }
2077 unless ($self->perl_script($pod2man_exe)) {
2078 # No pod2man but some MAN3PODS to be installed
2079 print <<END;
2080
2081Warning: I could not locate your pod2man program. Please make sure,
2082 your pod2man program is in your PATH before you execute 'make'
2083
2084END
2085 $pod2man_exe = "-S pod2man";
2086 }
2087 my(@m);
2088 push @m,
2089qq[POD2MAN_EXE = $pod2man_exe\n],
2090q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2091-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2092-e 'print "Manifying $$m{$$_}\n";' \\
2093-e 'system("$$^X \\"-I$(PERL_ARCHLIB)\\" \\"-I$(PERL_LIB)\\" $(POD2MAN_EXE) $$_>$$m{$$_}")==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2094-e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2095];
2096 push @m, "\nmanifypods : ";
2097 push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2098
2099 push(@m,"\n");
2100 if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2101 push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2102 push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2103 }
2104 join('', @m);
2105}
2106
2107=item processPL
2108
2109
2110
2111=cut
2112
2113sub processPL {
2114 my($self) = shift;
2115 unless (ref $self){
2116 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2117 $self = $ExtUtils::MakeMaker::Parent[-1];
2118 }
2119 return "" unless $self->{PL_FILES};
2120 my(@m, $plfile);
2121 foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2122 push @m, "
2123all :: $self->{PL_FILES}->{$plfile}
2124
2125$self->{PL_FILES}->{$plfile} :: $plfile
2126 \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2127";
2128 }
2129 join "", @m;
2130}
2131
2132=item installbin
2133
2134
2135
2136=cut
2137
2138sub installbin {
2139 my($self) = shift;
2140 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2141 return "" unless @{$self->{EXE_FILES}};
2142 my(@m, $from, $to, %fromto, @to);
2143 push @m, $self->dir_target(qw[$(INST_EXE)]);
2144 for $from (@{$self->{EXE_FILES}}) {
2145 my($path)= '$(INST_EXE)/' . basename($from);
2146 local($_) = $path; # for backwards compatibility
2147 $to = $self->libscan($path);
2148 print "libscan($from) => '$to'\n" if ($Verbose >=2);
2149 $fromto{$from}=$to;
2150 }
2151 @to = values %fromto;
2152 push(@m, "
2153EXE_FILES = @{$self->{EXE_FILES}}
2154
2155all :: @to
2156
2157realclean ::
2158 $self->{RM_F} @to
2159");
2160
2161 while (($from,$to) = each %fromto) {
2162 my $todir = dirname($to);
2163 push @m, "
2164$to: $from $self->{MAKEFILE} $todir/.exists
2165 $self->{CP} $from $to
2166";
2167 }
2168 join "", @m;
2169}
2170
2171=item subdirs
2172
2173
2174
2175=cut
2176
2177sub subdirs {
2178# --- Sub-directory Sections ---
2179 my($self) = shift;
2180 unless (ref $self){
2181 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2182 $self = $ExtUtils::MakeMaker::Parent[-1];
2183 }
2184 my(@m,$dir);
2185 # This method provides a mechanism to automatically deal with
2186 # subdirectories containing further Makefile.PL scripts.
2187 # It calls the subdir_x() method for each subdirectory.
2188 foreach $dir (@{$self->{DIR}}){
2189 push(@m, $self->subdir_x($dir));
2190#### print "Including $dir subdirectory\n";
2191 }
2192 if (@m){
2193 unshift(@m, "
2194# The default clean, realclean and test targets in this Makefile
2195# have automatically been given entries for each subdir.
2196
2197");
2198 } else {
2199 push(@m, "\n# none")
2200 }
2201 join('',@m);
2202}
2203
2204=item subdir_x
2205
2206
2207
2208=cut
2209
2210sub subdir_x {
2211 my($self, $subdir) = @_;
2212 unless (ref $self){
2213 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2214 $self = $ExtUtils::MakeMaker::Parent[-1];
2215 }
2216 my(@m);
2217 qq{
2218
2219subdirs ::
2220 $self->{NOECHO}-cd $subdir && \$(MAKE) all \$(PASTHRU)
2221
2222};
2223}
2224
2225=item clean
2226
2227
2228
2229=cut
2230
2231sub clean {
2232# --- Cleanup and Distribution Sections ---
2233
2234 my($self, %attribs) = @_;
2235 unless (ref $self){
2236 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2237 $self = $ExtUtils::MakeMaker::Parent[-1];
2238 }
2239 my(@m,$dir);
2240 push(@m, '
2241# Delete temporary files but do not touch installed files. We don\'t delete
2242# the Makefile here so a later make realclean still has a makefile to use.
2243
2244clean ::
2245');
2246 # clean subdirectories first
2247 for $dir (@{$self->{DIR}}) {
2248 push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
2249 }
2250
2251 my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
2252 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2253 push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
2254 perlmain.c mon.out core so_locations
2255 *~ */*~ */*/*~
2256 *$(OBJ_EXT) *$(LIB_EXT)
2257 perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
2258 ]);
2259 push @m, "\t-$self->{RM_RF} @otherfiles\n";
2260 # See realclean and ext/utils/make_ext for usage of Makefile.old
2261 push(@m,
2262 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
2263 push(@m,
2264 "\t$attribs{POSTOP}\n") if $attribs{POSTOP};
2265 join("", @m);
2266}
2267
2268=item realclean
2269
2270
2271
2272=cut
2273
2274sub realclean {
2275 my($self, %attribs) = @_;
2276 unless (ref $self){
2277 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2278 $self = $ExtUtils::MakeMaker::Parent[-1];
2279 }
2280 my(@m);
2281 push(@m,'
2282# Delete temporary files (via clean) and also delete installed files
2283realclean purge :: clean
2284');
2285 # realclean subdirectories first (already cleaned)
2286 my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
2287 foreach(@{$self->{DIR}}){
2288 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2289 push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2290 }
2291 push(@m, " $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2292 push(@m, " $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2293 push(@m, " $self->{RM_F} \$(INST_STATIC) \$(INST_PM)\n");
2294 my(@otherfiles) = ($self->{MAKEFILE},
2295 "$self->{MAKEFILE}.old"); # Makefiles last
2296 push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2297 push(@m, " $self->{RM_RF} @otherfiles\n") if @otherfiles;
2298 push(@m, " $attribs{POSTOP}\n") if $attribs{POSTOP};
2299 join("", @m);
2300}
2301
2302=item dist_basics
2303
2304
2305
2306=cut
2307
2308sub dist_basics {
2309 my($self) = shift;
2310 unless (ref $self){
2311 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2312 $self = $ExtUtils::MakeMaker::Parent[-1];
2313 }
2314 my @m;
2315 push @m, q{
2316distclean :: realclean distcheck
2317};
2318
2319 push @m, q{
2320distcheck :
2321 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
2322 -e 'fullcheck();'
2323};
2324
2325 push @m, q{
2326skipcheck :
2327 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
2328 -e 'skipcheck();'
2329};
2330
2331 push @m, q{
2332manifest :
2333 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
2334 -e 'mkmanifest();'
2335};
2336 join "", @m;
2337}
2338
2339=item dist_core
2340
2341
2342
2343=cut
2344
2345sub dist_core {
2346 my($self) = shift;
2347 unless (ref $self){
2348 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2349 $self = $ExtUtils::MakeMaker::Parent[-1];
2350 }
2351 my @m;
2352 push @m, q{
2353dist : $(DIST_DEFAULT)
2354
2355tardist : $(DISTVNAME).tar.$(SUFFIX)
2356
2357$(DISTVNAME).tar.$(SUFFIX) : distdir
2358 $(PREOP)
2359 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
2360 $(RM_RF) $(DISTVNAME)
2361 $(COMPRESS) $(DISTVNAME).tar
2362 $(POSTOP)
2363
2364uutardist : $(DISTVNAME).tar.$(SUFFIX)
2365 uuencode $(DISTVNAME).tar.$(SUFFIX) \\
2366 $(DISTVNAME).tar.$(SUFFIX) > \\
2367 $(DISTVNAME).tar.$(SUFFIX).uu
2368
2369shdist : distdir
2370 $(PREOP)
2371 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
2372 $(RM_RF) $(DISTVNAME)
2373 $(POSTOP)
2374};
2375 join "", @m;
2376}
2377
2378=item dist_dir
2379
2380
2381
2382=cut
2383
2384sub dist_dir {
2385 my($self) = shift;
2386 unless (ref $self){
2387 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2388 $self = $ExtUtils::MakeMaker::Parent[-1];
2389 }
2390 my @m;
2391 push @m, q{
2392distdir :
2393 $(RM_RF) $(DISTVNAME)
2394 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "/mani/";' \\
2395 -e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
2396};
2397 join "", @m;
2398}
2399
2400=item dist_test
2401
2402
2403
2404=cut
2405
2406sub dist_test {
2407 my($self) = shift;
2408 unless (ref $self){
2409 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2410 $self = $ExtUtils::MakeMaker::Parent[-1];
2411 }
2412 my @m;
2413 push @m, q{
2414disttest : distdir
2415 cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
2416 cd $(DISTVNAME) && $(MAKE)
2417 cd $(DISTVNAME) && $(MAKE) test
2418};
2419 join "", @m;
2420}
2421
2422=item dist_ci
2423
2424
2425
2426=cut
2427
2428sub dist_ci {
2429 my($self) = shift;
2430 unless (ref $self){
2431 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2432 $self = $ExtUtils::MakeMaker::Parent[-1];
2433 }
2434 my @m;
2435 push @m, q{
2436ci :
2437 $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
2438 -e '@all = keys %{ maniread() };' \\
2439 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
2440 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
2441};
2442 join "", @m;
2443}
2444
2445=item install
2446
2447
2448
2449=cut
2450
2451sub install {
2452 my($self, %attribs) = @_;
2453 unless (ref $self){
2454 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2455 $self = $ExtUtils::MakeMaker::Parent[-1];
2456 }
2457 my(@m);
2458
2459 push @m, q{
2460install :: all pure_install doc_install
2461
a5f75d66 2462install_perl :: all pure_perl_install doc_perl_install
1e44e2bf 2463
a5f75d66 2464install_site :: all pure_site_install doc_site_install
1e44e2bf
PP
2465
2466install_ :: install_site
2467 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2468
2469pure_install :: pure_$(INSTALLDIRS)_install
2470
2471doc_install :: doc_$(INSTALLDIRS)_install
2472 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2473
2474pure__install : pure_site_install
2475 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2476
2477doc__install : doc_site_install
2478 @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2479
2480pure_perl_install ::
2481 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2482 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2483 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2484 $(INST_LIB) $(INSTALLPRIVLIB) \
2485 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2486 $(INST_EXE) $(INSTALLBIN) \
2487 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2488 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2489 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2490 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2491
2492
2493pure_site_install ::
2494 }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2495 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2496 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2497 $(INST_LIB) $(INSTALLSITELIB) \
2498 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2499 $(INST_EXE) $(INSTALLBIN) \
2500 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2501 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2502 }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2503 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2504
2505doc_perl_install ::
2506 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2507 "$(NAME)" \
2508 "installed into" "$(INSTALLPRIVLIB)" \
2509 LINKTYPE "$(LINKTYPE)" \
2510 VERSION "$(VERSION)" \
2511 EXE_FILES "$(EXE_FILES)" \
2512 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2513
2514doc_site_install ::
2515 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2516 "Module $(NAME)" \
2517 "installed into" "$(INSTALLSITELIB)" \
2518 LINKTYPE "$(LINKTYPE)" \
2519 VERSION "$(VERSION)" \
2520 EXE_FILES "$(EXE_FILES)" \
2521 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2522
2523};
2524
2525 push @m, q{
2526uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2527
2528uninstall_from_perldirs ::
2529 }.$self->{NOECHO}.
2530 q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2531
2532uninstall_from_sitedirs ::
2533 }.$self->{NOECHO}.
2534 q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2535};
2536
2537 join("",@m);
2538}
2539
2540=item force
2541
2542
2543
2544=cut
2545
2546sub force {
2547 my($self) = shift;
2548 unless (ref $self){
2549 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2550 $self = $ExtUtils::MakeMaker::Parent[-1];
2551 }
2552 '# Phony target to force checking subdirectories.
2553FORCE:
2554';
2555}
2556
2557=item perldepend
2558
2559
2560
2561=cut
2562
2563sub perldepend {
2564 my($self) = shift;
2565 unless (ref $self){
2566 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2567 $self = $ExtUtils::MakeMaker::Parent[-1];
2568 }
2569 my(@m);
2570 push(@m,'
2571PERL_HDRS = $(PERL_INC)/EXTERN.h $(PERL_INC)/INTERN.h \
2572 $(PERL_INC)/XSUB.h $(PERL_INC)/av.h $(PERL_INC)/cop.h \
2573 $(PERL_INC)/cv.h $(PERL_INC)/dosish.h $(PERL_INC)/embed.h \
2574 $(PERL_INC)/form.h $(PERL_INC)/gv.h $(PERL_INC)/handy.h \
2575 $(PERL_INC)/hv.h $(PERL_INC)/keywords.h $(PERL_INC)/mg.h \
2576 $(PERL_INC)/op.h $(PERL_INC)/opcode.h $(PERL_INC)/patchlevel.h \
2577 $(PERL_INC)/perl.h $(PERL_INC)/perly.h $(PERL_INC)/pp.h \
2578 $(PERL_INC)/proto.h $(PERL_INC)/regcomp.h $(PERL_INC)/regexp.h \
2579 $(PERL_INC)/scope.h $(PERL_INC)/sv.h $(PERL_INC)/unixish.h \
2580 $(PERL_INC)/util.h $(PERL_INC)/config.h
2581
2582');
2583
2584 push @m, '
2585$(OBJECT) : $(PERL_HDRS)
2586' if $self->{OBJECT};
2587
2588 push(@m,'
2589# Check for unpropogated config.sh changes. Should never happen.
2590# We do NOT just update config.h because that is not sufficient.
2591# An out of date config.h is not fatal but complains loudly!
2592$(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2593 -'.$self->{NOECHO}.'echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2594
2595$(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2596 '.$self->{NOECHO}.'echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2597 cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2598') if $self->{PERL_SRC};
2599
2600 push(@m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n")
2601 if %{$self->{XS}};
2602 join("\n",@m);
2603}
2604
2605=item makefile
2606
2607
2608
2609=cut
2610
2611sub makefile {
2612 my($self) = shift;
2613 unless (ref $self){
2614 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2615 $self = $ExtUtils::MakeMaker::Parent[-1];
2616 }
2617 my @m;
2618 # We do not know what target was originally specified so we
2619 # must force a manual rerun to be sure. But as it should only
2620 # happen very rarely it is not a significant problem.
2621 push @m, '
2622$(OBJECT) : $(FIRST_MAKEFILE)
2623' if $self->{OBJECT};
2624
2625 push @m, '
2626# We take a very conservative approach here, but it\'s worth it.
2627# We move Makefile to Makefile.old here to avoid gnu make looping.
2628'.$self->{MAKEFILE}.' : Makefile.PL $(CONFIGDEP)
2629 '.$self->{NOECHO}.'echo "Makefile out-of-date with respect to $?"
2630 '.$self->{NOECHO}.'echo "Cleaning current config before rebuilding Makefile..."
2631 -'.$self->{NOECHO}.'mv '."$self->{MAKEFILE} $self->{MAKEFILE}.old".'
2632 -$(MAKE) -f '.$self->{MAKEFILE}.'.old clean >/dev/null 2>&1 || true
2633 $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL '.join(" ",map(qq["$_"],@ARGV)).'
2634 '.$self->{NOECHO}.'echo ">>> Your Makefile has been rebuilt. <<<"
2635 '.$self->{NOECHO}.'echo ">>> Please rerun the make command. <<<"; false
2636';
2637
2638 join "", @m;
2639}
2640
2641=item staticmake
2642
2643
2644
2645=cut
2646
2647sub staticmake {
2648 my($self, %attribs) = @_;
2649 unless (ref $self){
2650 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2651 $self = $ExtUtils::MakeMaker::Parent[-1];
2652 }
2653 my(@static);
2654
2655 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
2656
2657 # And as it's not yet built, we add the current extension
2658 # but only if it has some C code (or XS code, which implies C code)
2659 if (@{$self->{C}}) {
2660 @static="$self->{INST_ARCHLIB}/auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}";
2661 }
2662
2663 # Either we determine now, which libraries we will produce in the
2664 # subdirectories or we do it at runtime of the make.
2665
2666 # We could ask all subdir objects, but I cannot imagine, why it
2667 # would be necessary.
2668
2669 # Instead we determine all libraries for the new perl at
2670 # runtime.
2671 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2672
2673 $self->makeaperl(MAKE => $self->{MAKEFILE},
2674 DIRS => \@searchdirs,
2675 STAT => \@static,
2676 INCL => \@perlinc,
2677 TARGET => $self->{MAP_TARGET},
2678 TMP => "",
2679 LIBPERL => $self->{LIBPERL_A}
2680 );
2681}
2682
2683=item test
2684
2685
2686
2687=cut
2688
2689sub test {
2690# --- Test and Installation Sections ---
2691
2692 my($self, %attribs) = @_;
2693 unless (ref $self){
2694 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2695 $self = $ExtUtils::MakeMaker::Parent[-1];
2696 }
2697 my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2698 my(@m);
2699 push(@m,"
2700TEST_VERBOSE=0
2701TEST_TYPE=test_\$(LINKTYPE)
2702
2703test :: \$(TEST_TYPE)
2704");
2705 push(@m, map("\t$self->{NOECHO}cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2706 @{$self->{DIR}}));
2707 push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
2708 unless $tests or -f "test.pl" or @{$self->{DIR}};
2709 push(@m, "\n");
2710
2711 push(@m, "test_dynamic :: all\n");
2712 push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2713 push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2714 push(@m, "\n");
2715
2716 # Occasionally we may face this degenerate target:
2717 push @m, "test_ : test_dynamic\n\n";
2718
2719 if ($self->needs_linking()) {
2720 push(@m, "test_static :: all \$(MAP_TARGET)\n");
2721 push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2722 push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2723 push(@m, "\n");
2724 } else {
2725 push @m, "test_static :: test_dynamic\n";
2726 }
2727 join("", @m);
2728}
2729
2730=item test_via_harness
2731
2732
2733
2734=cut
2735
2736sub test_via_harness {
2737 my($self, $perl, $tests) = @_;
2738 unless (ref $self){
2739 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2740 $self = $ExtUtils::MakeMaker::Parent[-1];
2741 }
2742 "\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";
2743}
2744
2745=item test_via_script
2746
2747
2748
2749=cut
2750
2751sub test_via_script {
2752 my($self, $perl, $script) = @_;
2753 unless (ref $self){
2754 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2755 $self = $ExtUtils::MakeMaker::Parent[-1];
2756 }
2757 qq{\tPERL_DL_NONLAZY=1 $perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
2758};
2759}
2760
2761=item postamble
2762
2763Returns an empty string. Can be used in Makefile.PLs to write some
2764text to the Makefile at the end.
2765
2766=cut
2767
2768sub postamble {
2769 my($self) = shift;
2770 unless (ref $self){
2771 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2772 $self = $ExtUtils::MakeMaker::Parent[-1];
2773 }
2774 "";
2775}
2776
2777=item makeaperl
2778
2779Called by staticmake.
2780
2781=cut
2782
2783sub makeaperl {
2784 my($self, %attribs) = @_;
2785 unless (ref $self){
2786 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2787 $self = $ExtUtils::MakeMaker::Parent[-1];
2788 }
2789 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2790 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2791 my(@m);
2792 push @m, "
2793# --- MakeMaker makeaperl section ---
2794MAP_TARGET = $target
2795FULLPERL = $self->{FULLPERL}
2796";
2797 return join '', @m if $self->{PARENT};
2798
2799 my($dir) = join ":", @{$self->{DIR}};
2800
2801 unless ($self->{MAKEAPERL}) {
2802 push @m, q{
2803$(MAP_TARGET) :: $(MAKE_APERL_FILE)
2804 $(MAKE) -f $(MAKE_APERL_FILE) static $@
2805
2806$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2807 }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2808 }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2809 Makefile.PL DIR=}, $dir, q{ \
2810 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2811 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2812
2813 push @m, map( " \\\n\t\t$_", @ARGV );
2814 push @m, "\n";
2815
2816 return join '', @m;
2817 }
2818
2819
2820
2821 my($cccmd, $linkcmd, $lperl);
2822
2823
2824 $cccmd = $self->const_cccmd($libperl);
2825 $cccmd =~ s/^CCCMD\s*=\s*//;
2826 $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2827 $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
2828 $cccmd =~ s/\n/ /g; # yes I've seen "\n", don't ask me where it came from. A.K.
2829 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2830
2831 # The front matter of the linkcommand...
2832 $linkcmd = join ' ', "\$(CC)",
2833 grep($_, @Config{qw(large split ldflags ccdlflags)});
2834 $linkcmd =~ s/\s+/ /g;
2835
2836 # Which *.a files could we make use of...
2837 local(%static);
2838 File::Find::find(sub {
2839 return unless m/\Q$self->{LIB_EXT}\E$/;
2840 return if m/^libperl/;
2841 # don't include the installed version of this extension. I
2842 # leave this line here, although it is not necessary anymore:
2843 # I patched minimod.PL instead, so that Miniperl.pm won't
2844 # enclude duplicates
2845
2846 # Once the patch to minimod.PL is in the distribution, I can
2847 # drop it
2848 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2849 $static{fastcwd() . "/" . $_}++;
2850 }, grep( -d $_, @{$searchdirs || []}) );
2851
2852 # We trust that what has been handed in as argument, will be buildable
2853 $static = [] unless $static;
2854 @static{@{$static}} = (1) x @{$static};
2855
2856 $extra = [] unless $extra && ref $extra eq 'ARRAY';
2857 for (sort keys %static) {
2858 next unless /\Q$self->{LIB_EXT}\E$/;
2859 $_ = dirname($_) . "/extralibs.ld";
2860 push @$extra, $_;
2861 }
2862
2863 grep(s/^/-I/, @{$perlinc || []});
2864
2865 $target = "perl" unless $target;
2866 $tmp = "." unless $tmp;
2867
2868# MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2869# regenerate the Makefiles, MAP_STATIC and the dependencies for
2870# extralibs.all are computed correctly
2871 push @m, "
2872MAP_LINKCMD = $linkcmd
2873MAP_PERLINC = @{$perlinc || []}
2874MAP_STATIC = ",
2875join(" \\\n\t", reverse sort keys %static), "
2876
2877MAP_PRELIBS = $Config::Config{libs} $Config::Config{cryptlib}
2878";
2879
2880 if (defined $libperl) {
2881 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2882 }
2883 unless ($libperl && -f $lperl) { # Ilya's code...
2884 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2885 $libperl ||= "libperl$self->{LIB_EXT}";
2886 $libperl = "$dir/$libperl";
2887 $lperl ||= "libperl$self->{LIB_EXT}";
2888 $lperl = "$dir/$lperl";
2889 print STDOUT "Warning: $libperl not found
2890 If you're going to build a static perl binary, make sure perl is installed
2891 otherwise ignore this warning\n"
2892 unless (-f $lperl || defined($self->{PERL_SRC}));
2893 }
2894
2895 push @m, "
2896MAP_LIBPERL = $libperl
2897";
2898
2899 push @m, "
2900\$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2901 $self->{NOECHO}$self->{RM_F} \$\@
2902 $self->{NOECHO}\$(TOUCH) \$\@
2903";
2904
2905 my $catfile;
2906 foreach $catfile (@$extra){
2907 push @m, "\tcat $catfile >> \$\@\n";
2908 }
2909
2910 push @m, "
2911\$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2912 \$(MAP_LINKCMD) -o \$\@ $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2913 $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2914 $self->{NOECHO}echo ' make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2915 $self->{NOECHO}echo 'To remove the intermediate files say'
2916 $self->{NOECHO}echo ' make -f $makefilename map_clean'
2917
2918$tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2919";
2920 push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2921
2922 push @m, qq{
2923$tmp/perlmain.c: $makefilename}, q{
2924 }.$self->{NOECHO}.q{echo Writing $@
2925 }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
2926 writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
2927
2928};
2929
2930 push @m, q{
2931doc_inst_perl:
2932 }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2933 }.$self->{NOECHO}.q{$(DOC_INSTALL) \
2934 "Perl binary $(MAP_TARGET)" \
2935 MAP_STATIC "$(MAP_STATIC)" \
2936 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2937 MAP_LIBPERL "$(MAP_LIBPERL)" \
2938 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2939
2940};
2941
2942 push @m, qq{
2943inst_perl: pure_inst_perl doc_inst_perl
2944
2945pure_inst_perl: \$(MAP_TARGET)
2946 $self->{CP} \$(MAP_TARGET) \$(INSTALLBIN)/\$(MAP_TARGET)
2947
2948clean :: map_clean
2949
2950map_clean :
2951 $self->{RM_F} $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2952};
2953
2954 join '', @m;
2955}
2956
2957=item extliblist
2958
2959Called by init_others.
2960
2961=cut
2962
2963sub extliblist {
2964 my($self,$libs) = @_;
2965 unless (ref $self){
2966 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2967 $self = $ExtUtils::MakeMaker::Parent[-1];
2968 }
2969 $self->ext($libs, $Verbose);
2970}
2971
2972=item dir_target
2973
2974Takes an array of directories that need to exist and returns a
2975Makefile entry for a .exists file in these directories. Returns
2976nothing, if the entry has already been processed. We're helpless
2977though, if the same directory comes as $(FOO) _and_ as "bar". Both of
2978them get an entry, that's why we use "::".
2979
2980=cut
2981
2982sub dir_target {
2983# --- Make-Directories section (internal method) ---
2984# dir_target(@array) returns a Makefile entry for the file .exists in each
2985# named directory. Returns nothing, if the entry has already been processed.
2986# We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
2987# Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
2988# prerequisite, because there has to be one, something that doesn't change
2989# too often :)
2990
2991 my($self,@dirs) = @_;
2992 unless (ref $self){
2993 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2994 $self = $ExtUtils::MakeMaker::Parent[-1];
2995 }
2996 my(@m,$dir);
2997 foreach $dir (@dirs) {
2998 next if $self->{DIR_TARGET}{$self}{$dir}++;
2999 push @m, qq{
3000$dir/.exists :: }.$self->catfile($self->{PERL_INC},"perl.h").qq{
3001 $self->{NOECHO}\$(MKPATH) $dir
3002 $self->{NOECHO}\$(EQUALIZE_TIMESTAMP) \$(PERL) $dir/.exists
3003 -$self->{NOECHO}\$(CHMOD) 755 $dir
3004};
3005 }
3006 join "", @m;
3007}
3008
3009=item needs_linking
3010
3011Does this module need linking? Looks into subdirectory objects (see
3012also has_link_code())
3013
3014=cut
3015
3016sub needs_linking {
3017 my($self) = shift;
3018 my($child,$caller);
3019 $caller = (caller(0))[3];
3020 unless (ref $self){
3021 ExtUtils::MakeMaker::TieAtt::warndirectuse($caller);
3022 $self = $ExtUtils::MakeMaker::Parent[-1];
3023 }
3024 Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
3025 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
3026 if ($self->has_link_code or $self->{MAKEAPERL}){
3027 $self->{NEEDS_LINKING} = 1;
3028 return 1;
3029 }
3030 foreach $child (keys %{$self->{CHILDREN}}) {
3031 if ($self->{CHILDREN}->{$child}->needs_linking) {
3032 $self->{NEEDS_LINKING} = 1;
3033 return 1;
3034 }
3035 }
3036 return $self->{NEEDS_LINKING} = 0;
3037}
3038
3039=item has_link_code
3040
3041Returns true if C, XS, MYEXTLIB or similar objects exist within this
3042object that need a compiler. Does not descend into subdirectories as
3043needs_linking() does.
3044
3045=cut
3046
3047sub has_link_code {
3048 my($self) = shift;
3049 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
3050 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
3051 $self->{HAS_LINK_CODE} = 1;
3052 return 1;
3053 }
3054 return $self->{HAS_LINK_CODE} = 0;
3055}
3056
3057=item writedoc
3058
3059Obsolete, depecated method.
3060
3061=cut
3062
3063sub writedoc {
3064# --- perllocal.pod section ---
3065 my($self,$what,$name,@attribs)=@_;
3066 unless (ref $self){
3067 ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3068 $self = $ExtUtils::MakeMaker::Parent[-1];
3069 }
3070 my $time = localtime;
3071 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3072 print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3073 print "\n\n=back\n\n";
3074}
3075
3076=head1 SEE ALSO
3077
3078L<ExtUtils::MakeMaker>
3079
3080=cut
3081
30821;
3083