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