This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
22999739946872d89ffc4e293c8e7d24ff684161
[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.12601 $, 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} || 'gzip --best';
731     my($suffix)   = $attribs{SUFFIX}   || '.gz';          # 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 \$(MAP_STATIC) $llibperl `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{$(RM_F) }."$self->{MAKEFILE}.old".q{
2407         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2408         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2409         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2410         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2411         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2412         false
2413
2414 # To change behavior to :: would be nice, but would break Tk b9.02
2415 # so you find such a warning below the dist target.
2416 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2417 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2418 };
2419
2420     join "", @m;
2421 }
2422
2423 =item manifypods (o)
2424
2425 Defines targets and routines to translate the pods into manpages and
2426 put them into the INST_* directories.
2427
2428 =cut
2429
2430 sub manifypods {
2431     my($self, %attribs) = @_;
2432     return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2433     my($dist);
2434     my($pod2man_exe);
2435     if (defined $self->{PERL_SRC}) {
2436         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2437     } else {
2438         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2439     }
2440     unless ($self->perl_script($pod2man_exe)) {
2441         # No pod2man but some MAN3PODS to be installed
2442         print <<END;
2443
2444 Warning: I could not locate your pod2man program. Please make sure,
2445          your pod2man program is in your PATH before you execute 'make'
2446
2447 END
2448         $pod2man_exe = "-S pod2man";
2449     }
2450     my(@m);
2451     push @m,
2452 qq[POD2MAN_EXE = $pod2man_exe\n],
2453 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2454 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2455  $self->{MAKEFILE}, q[";' \\
2456 -e 'print "Manifying $$m{$$_}\n";' \\
2457 -e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2458 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2459 ];
2460     push @m, "\nmanifypods : ";
2461     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2462
2463     push(@m,"\n");
2464     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2465         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2466         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2467     }
2468     join('', @m);
2469 }
2470
2471 =item maybe_command
2472
2473 Returns true, if the argument is likely to be a command.
2474
2475 =cut
2476
2477 sub maybe_command {
2478     my($self,$file) = @_;
2479     return $file if -x $file && ! -d $file;
2480     return;
2481 }
2482
2483 =item maybe_command_in_dirs
2484
2485 method under development. Not yet used. Ask Ilya :-)
2486
2487 =cut
2488
2489 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2490 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2491     my($self, $names, $dirs, $trace, $ver) = @_;
2492     my($name, $dir);
2493     foreach $dir (@$dirs){
2494         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2495         foreach $name (@$names){
2496             my($abs,$tryabs);
2497             if ($self->file_name_is_absolute($name)) { # /foo/bar
2498                 $abs = $name;
2499             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2500                 $abs = $self->catfile($dir, $name);
2501             } else { # foo/bar
2502                 $abs = $self->catfile($self->curdir, $name);
2503             }
2504             print "Checking $abs for $name\n" if ($trace >= 2);
2505             next unless $tryabs = $self->maybe_command($abs);
2506             print "Substituting $tryabs instead of $abs\n"
2507                 if ($trace >= 2 and $tryabs ne $abs);
2508             $abs = $tryabs;
2509             if (defined $ver) {
2510                 print "Executing $abs\n" if ($trace >= 2);
2511                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2512                     print "Using PERL=$abs\n" if $trace;
2513                     return $abs;
2514                 }
2515             } else { # Do not look for perl
2516                 return $abs;
2517             }
2518         }
2519     }
2520 }
2521
2522 =item needs_linking (o)
2523
2524 Does this module need linking? Looks into subdirectory objects (see
2525 also has_link_code())
2526
2527 =cut
2528
2529 sub needs_linking {
2530     my($self) = shift;
2531     my($child,$caller);
2532     $caller = (caller(0))[3];
2533     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2534     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2535     if ($self->has_link_code or $self->{MAKEAPERL}){
2536         $self->{NEEDS_LINKING} = 1;
2537         return 1;
2538     }
2539     foreach $child (keys %{$self->{CHILDREN}}) {
2540         if ($self->{CHILDREN}->{$child}->needs_linking) {
2541             $self->{NEEDS_LINKING} = 1;
2542             return 1;
2543         }
2544     }
2545     return $self->{NEEDS_LINKING} = 0;
2546 }
2547
2548 =item nicetext
2549
2550 misnamed method (will have to be changed). The MM_Unix method just
2551 returns the argument without further processing.
2552
2553 On VMS used to insure that colons marking targets are preceded by
2554 space - most Unix Makes don't need this, but it's necessary under VMS
2555 to distinguish the target delimiter from a colon appearing as part of
2556 a filespec.
2557
2558 =cut
2559
2560 sub nicetext {
2561     my($self,$text) = @_;
2562     $text;
2563 }
2564
2565 =item parse_version
2566
2567 parse a file and return what you think is $VERSION in this file set to
2568
2569 =cut
2570
2571 sub parse_version {
2572     my($self,$parsefile) = @_;
2573     my $result;
2574     local *FH;
2575     local $/ = "\n";
2576     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2577     my $inpod = 0;
2578     while (<FH>) {
2579         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2580         next if $inpod;
2581         chop;
2582         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2583         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2584         my $eval = qq{
2585             package ExtUtils::MakeMaker::_version;
2586             no strict;
2587
2588             local $1$2;
2589             \$$2=undef; do {
2590                 $_
2591             }; \$$2
2592         };
2593         local($^W) = 0;
2594         $result = eval($eval);
2595         die "Could not eval '$eval' in $parsefile: $@" if $@;
2596         $result = "undef" unless defined $result;
2597         last;
2598     }
2599     close FH;
2600     return $result;
2601 }
2602
2603 =item parse_abstract
2604
2605 parse a file and return what you think is the ABSTRACT
2606
2607 =cut
2608
2609 sub parse_abstract {
2610     my($self,$parsefile) = @_;
2611     my $result;
2612     local *FH;
2613     local $/ = "\n";
2614     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2615     my $inpod = 0;
2616     my $package = $self->{DISTNAME};
2617     $package =~ s/-/::/;
2618     while (<FH>) {
2619         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2620         next if !$inpod;
2621         chop;
2622         next unless /^($package\s-\s)(.*)/;
2623         $result = $2;
2624         last;
2625     }
2626     close FH;
2627     return $result;
2628 }
2629
2630 =item pasthru (o)
2631
2632 Defines the string that is passed to recursive make calls in
2633 subdirectories.
2634
2635 =cut
2636
2637 sub pasthru {
2638     my($self) = shift;
2639     my(@m,$key);
2640
2641     my(@pasthru);
2642     my($sep) = $Is_VMS ? ',' : '';
2643     $sep .= "\\\n\t";
2644
2645     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
2646         push @pasthru, "$key=\"\$($key)\"";
2647     }
2648
2649     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2650     join "", @m;
2651 }
2652
2653 =item path
2654
2655 Takes no argument, returns the environment variable PATH as an array.
2656
2657 =cut
2658
2659 sub path {
2660     my($self) = @_;
2661     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2662     my $path = $ENV{PATH};
2663     $path =~ s:\\:/:g if $Is_OS2;
2664     my @path = split $path_sep, $path;
2665     foreach(@path) { $_ = '.' if $_ eq '' }
2666     @path;
2667 }
2668
2669 =item perl_script
2670
2671 Takes one argument, a file name, and returns the file name, if the
2672 argument is likely to be a perl script. On MM_Unix this is true for
2673 any ordinary, readable file.
2674
2675 =cut
2676
2677 sub perl_script {
2678     my($self,$file) = @_;
2679     return $file if -r $file && -f _;
2680     return;
2681 }
2682
2683 =item perldepend (o)
2684
2685 Defines the dependency from all *.h files that come with the perl
2686 distribution.
2687
2688 =cut
2689
2690 sub perldepend {
2691     my($self) = shift;
2692     my(@m);
2693     push @m, q{
2694 # Check for unpropogated config.sh changes. Should never happen.
2695 # We do NOT just update config.h because that is not sufficient.
2696 # An out of date config.h is not fatal but complains loudly!
2697 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2698         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2699
2700 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2701         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2702         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2703 } if $self->{PERL_SRC};
2704
2705     return join "", @m unless $self->needs_linking;
2706
2707     push @m, q{
2708 PERL_HDRS = \
2709 $(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
2710 $(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
2711 $(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
2712 $(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
2713 $(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
2714 $(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h       \
2715 $(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
2716 $(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
2717 $(PERL_INC)/embed.h        $(PERL_INC)/perl.h         $(PERL_INC)/iperlsys.h \
2718 $(PERL_INC)/form.h         $(PERL_INC)/perly.h
2719
2720 $(OBJECT) : $(PERL_HDRS)
2721 } if $self->{OBJECT};
2722
2723     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2724
2725     join "\n", @m;
2726 }
2727
2728 =item ppd
2729
2730 Defines target that creates a PPD (Perl Package Description) file
2731 for a binary distribution.
2732
2733 =cut
2734
2735 sub ppd {
2736     my($self) = @_;
2737     my(@m);
2738     if ($self->{ABSTRACT_FROM}){
2739         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2740             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2741     }
2742     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2743     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2744     push(@m, "ppd:\n");
2745     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2746     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2747     my $abstract = $self->{ABSTRACT};
2748     $abstract =~ s/</&lt;/g;
2749     $abstract =~ s/>/&gt;/g;
2750     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
2751     my ($author) = $self->{AUTHOR};
2752     $author =~ s/@/\\@/g;
2753     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
2754     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
2755     my ($prereq);
2756     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
2757         my $pre_req = $prereq;
2758         $pre_req =~ s/::/-/g;
2759         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" />\\n}");
2760     }
2761     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
2762     my ($bin_location) = $self->{BINARY_LOCATION};
2763     $bin_location =~ s/\\/\\\\/g;
2764     if ($self->{PPM_INSTALL_SCRIPT}) {
2765         if ($self->{PPM_INSTALL_EXEC}) {
2766             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2767         }
2768         else {
2769             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
2770         }
2771     }
2772     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
2773     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
2774     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
2775
2776     join("", @m);   
2777 }
2778
2779 =item perm_rw (o)
2780
2781 Returns the attribute C<PERM_RW> or the string C<644>.
2782 Used as the string that is passed
2783 to the C<chmod> command to set the permissions for read/writeable files.
2784 MakeMaker chooses C<644> because it has turned out in the past that
2785 relying on the umask provokes hard-to-track bugreports.
2786 When the return value is used by the perl function C<chmod>, it is
2787 interpreted as an octal value.
2788
2789 =cut
2790
2791 sub perm_rw {
2792     shift->{PERM_RW} || "644";
2793 }
2794
2795 =item perm_rwx (o)
2796
2797 Returns the attribute C<PERM_RWX> or the string C<755>,
2798 i.e. the string that is passed
2799 to the C<chmod> command to set the permissions for executable files.
2800 See also perl_rw.
2801
2802 =cut
2803
2804 sub perm_rwx {
2805     shift->{PERM_RWX} || "755";
2806 }
2807
2808 =item pm_to_blib
2809
2810 Defines target that copies all files in the hash PM to their
2811 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2812
2813 =cut
2814
2815 sub pm_to_blib {
2816     my $self = shift;
2817     my($autodir) = $self->catdir('$(INST_LIB)','auto');
2818     return q{
2819 pm_to_blib: $(TO_INST_PM)
2820         }.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
2821         "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
2822         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{')"
2823         }.$self->{NOECHO}.q{$(TOUCH) $@
2824 };
2825 }
2826
2827 =item post_constants (o)
2828
2829 Returns an empty string per default. Dedicated to overrides from
2830 within Makefile.PL after all constants have been defined.
2831
2832 =cut
2833
2834 sub post_constants{
2835     my($self) = shift;
2836     "";
2837 }
2838
2839 =item post_initialize (o)
2840
2841 Returns an empty string per default. Used in Makefile.PLs to add some
2842 chunk of text to the Makefile after the object is initialized.
2843
2844 =cut
2845
2846 sub post_initialize {
2847     my($self) = shift;
2848     "";
2849 }
2850
2851 =item postamble (o)
2852
2853 Returns an empty string. Can be used in Makefile.PLs to write some
2854 text to the Makefile at the end.
2855
2856 =cut
2857
2858 sub postamble {
2859     my($self) = shift;
2860     "";
2861 }
2862
2863 =item prefixify
2864
2865 Check a path variable in $self from %Config, if it contains a prefix,
2866 and replace it with another one.
2867
2868 Takes as arguments an attribute name, a search prefix and a
2869 replacement prefix. Changes the attribute in the object.
2870
2871 =cut
2872
2873 sub prefixify {
2874     my($self,$var,$sprefix,$rprefix) = @_;
2875     $self->{uc $var} ||= $Config{lc $var};
2876     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
2877     $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
2878 }
2879
2880 =item processPL (o)
2881
2882 Defines targets to run *.PL files.
2883
2884 =cut
2885
2886 sub processPL {
2887     my($self) = shift;
2888     return "" unless $self->{PL_FILES};
2889     my(@m, $plfile);
2890     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2891         push @m, "
2892 all :: $self->{PL_FILES}->{$plfile}
2893         $self->{NOECHO}\$(NOOP)
2894
2895 $self->{PL_FILES}->{$plfile} :: $plfile
2896         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2897 ";
2898     }
2899     join "", @m;
2900 }
2901
2902 =item realclean (o)
2903
2904 Defines the realclean target.
2905
2906 =cut
2907
2908 sub realclean {
2909     my($self, %attribs) = @_;
2910     my(@m);
2911     push(@m,'
2912 # Delete temporary files (via clean) and also delete installed files
2913 realclean purge ::  clean
2914 ');
2915     # realclean subdirectories first (already cleaned)
2916     my $sub = "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
2917     foreach(@{$self->{DIR}}){
2918         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2919         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2920     }
2921     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2922     if( $self->has_link_code ){
2923         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2924         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
2925     }
2926     push(@m, "  $self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
2927     my(@otherfiles) = ($self->{MAKEFILE},
2928                        "$self->{MAKEFILE}.old"); # Makefiles last
2929     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2930     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2931     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2932     join("", @m);
2933 }
2934
2935 =item replace_manpage_separator
2936
2937 Takes the name of a package, which may be a nested package, in the
2938 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
2939
2940 =cut
2941
2942 sub replace_manpage_separator {
2943     my($self,$man) = @_;
2944     $man =~ s,/+,::,g;
2945     $man;
2946 }
2947
2948 =item static (o)
2949
2950 Defines the static target.
2951
2952 =cut
2953
2954 sub static {
2955 # --- Static Loading Sections ---
2956
2957     my($self) = shift;
2958     '
2959 ## $(INST_PM) has been moved to the all: target.
2960 ## It remains here for awhile to allow for old usage: "make static"
2961 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2962 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
2963         '.$self->{NOECHO}.'$(NOOP)
2964 ';
2965 }
2966
2967 =item static_lib (o)
2968
2969 Defines how to produce the *.a (or equivalent) files.
2970
2971 =cut
2972
2973 sub static_lib {
2974     my($self) = @_;
2975 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2976 #    return '' unless $self->needs_linking(); #might be because of a subdir
2977
2978     return '' unless $self->has_link_code;
2979
2980     my(@m);
2981     push(@m, <<'END');
2982 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2983         $(RM_RF) $@
2984 END
2985     # If this extension has it's own library (eg SDBM_File)
2986     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2987     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2988
2989     push @m,
2990 q{      $(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
2991         $(CHMOD) $(PERM_RWX) $@
2992         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2993 };
2994     # Old mechanism - still available:
2995     push @m,
2996 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
2997 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
2998     push @m, "\n";
2999
3000     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3001     join('', "\n",@m);
3002 }
3003
3004 =item staticmake (o)
3005
3006 Calls makeaperl.
3007
3008 =cut
3009
3010 sub staticmake {
3011     my($self, %attribs) = @_;
3012     my(@static);
3013
3014     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3015
3016     # And as it's not yet built, we add the current extension
3017     # but only if it has some C code (or XS code, which implies C code)
3018     if (@{$self->{C}}) {
3019         @static = $self->catfile($self->{INST_ARCHLIB},
3020                                  "auto",
3021                                  $self->{FULLEXT},
3022                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3023                                 );
3024     }
3025
3026     # Either we determine now, which libraries we will produce in the
3027     # subdirectories or we do it at runtime of the make.
3028
3029     # We could ask all subdir objects, but I cannot imagine, why it
3030     # would be necessary.
3031
3032     # Instead we determine all libraries for the new perl at
3033     # runtime.
3034     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3035
3036     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3037                      DIRS       => \@searchdirs,
3038                      STAT       => \@static,
3039                      INCL       => \@perlinc,
3040                      TARGET     => $self->{MAP_TARGET},
3041                      TMP        => "",
3042                      LIBPERL    => $self->{LIBPERL_A}
3043                     );
3044 }
3045
3046 =item subdir_x (o)
3047
3048 Helper subroutine for subdirs
3049
3050 =cut
3051
3052 sub subdir_x {
3053     my($self, $subdir) = @_;
3054     my(@m);
3055     qq{
3056
3057 subdirs ::
3058         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3059
3060 };
3061 }
3062
3063 =item subdirs (o)
3064
3065 Defines targets to process subdirectories.
3066
3067 =cut
3068
3069 sub subdirs {
3070 # --- Sub-directory Sections ---
3071     my($self) = shift;
3072     my(@m,$dir);
3073     # This method provides a mechanism to automatically deal with
3074     # subdirectories containing further Makefile.PL scripts.
3075     # It calls the subdir_x() method for each subdirectory.
3076     foreach $dir (@{$self->{DIR}}){
3077         push(@m, $self->subdir_x($dir));
3078 ####    print "Including $dir subdirectory\n";
3079     }
3080     if (@m){
3081         unshift(@m, "
3082 # The default clean, realclean and test targets in this Makefile
3083 # have automatically been given entries for each subdir.
3084
3085 ");
3086     } else {
3087         push(@m, "\n# none")
3088     }
3089     join('',@m);
3090 }
3091
3092 =item test (o)
3093
3094 Defines the test targets.
3095
3096 =cut
3097
3098 sub test {
3099 # --- Test and Installation Sections ---
3100
3101     my($self, %attribs) = @_;
3102     my $tests = $attribs{TESTS};
3103     if (!$tests && -d 't') {
3104         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3105     }
3106     # note: 'test.pl' name is also hardcoded in init_dirscan()
3107     my(@m);
3108     push(@m,"
3109 TEST_VERBOSE=0
3110 TEST_TYPE=test_\$(LINKTYPE)
3111 TEST_FILE = test.pl
3112 TEST_FILES = $tests
3113 TESTDB_SW = -d
3114
3115 testdb :: testdb_\$(LINKTYPE)
3116
3117 test :: \$(TEST_TYPE)
3118 ");
3119     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3120                  @{$self->{DIR}}));
3121     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3122         unless $tests or -f "test.pl" or @{$self->{DIR}};
3123     push(@m, "\n");
3124
3125     push(@m, "test_dynamic :: pure_all\n");
3126     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3127     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3128     push(@m, "\n");
3129
3130     push(@m, "testdb_dynamic :: pure_all\n");
3131     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3132     push(@m, "\n");
3133
3134     # Occasionally we may face this degenerate target:
3135     push @m, "test_ : test_dynamic\n\n";
3136
3137     if ($self->needs_linking()) {
3138         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3139         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3140         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3141         push(@m, "\n");
3142         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3143         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3144         push(@m, "\n");
3145     } else {
3146         push @m, "test_static :: test_dynamic\n";
3147         push @m, "testdb_static :: testdb_dynamic\n";
3148     }
3149     join("", @m);
3150 }
3151
3152 =item test_via_harness (o)
3153
3154 Helper method to write the test targets
3155
3156 =cut
3157
3158 sub test_via_harness {
3159     my($self, $perl, $tests) = @_;
3160     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3161     "\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";
3162 }
3163
3164 =item test_via_script (o)
3165
3166 Other helper method for test.
3167
3168 =cut
3169
3170 sub test_via_script {
3171     my($self, $perl, $script) = @_;
3172     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3173     qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3174 };
3175 }
3176
3177 =item tool_autosplit (o)
3178
3179 Defines a simple perl call that runs autosplit. May be deprecated by
3180 pm_to_blib soon.
3181
3182 =cut
3183
3184 sub tool_autosplit {
3185 # --- Tool Sections ---
3186
3187     my($self, %attribs) = @_;
3188     my($asl) = "";
3189     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3190     q{
3191 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3192 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3193 };
3194 }
3195
3196 =item tools_other (o)
3197
3198 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3199 the Makefile. Also defines the perl programs MKPATH,
3200 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3201
3202 =cut
3203
3204 sub tools_other {
3205     my($self) = shift;
3206     my @m;
3207     my $bin_sh = $Config{sh} || '/bin/sh';
3208     push @m, qq{
3209 SHELL = $bin_sh
3210 };
3211
3212     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3213         push @m, "$_ = $self->{$_}\n";
3214     }
3215
3216     push @m, q{
3217 # The following is a portable way to say mkdir -p
3218 # To see which directories are created, change the if 0 to if 1
3219 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3220
3221 # This helps us to minimize the effect of the .exists files A yet
3222 # better solution would be to have a stable file in the perl
3223 # distribution with a timestamp of zero. But this solution doesn't
3224 # need any changes to the core distribution and works with older perls
3225 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3226 };
3227
3228
3229     return join "", @m if $self->{PARENT};
3230
3231     push @m, q{
3232 # Here we warn users that an old packlist file was found somewhere,
3233 # and that they should call some uninstall routine
3234 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3235 -e 'print "WARNING: I have found an old package in\n";' \\
3236 -e 'print "\t$$ARGV[0].\n";' \\
3237 -e 'print "Please make sure the two installations are not conflicting\n";'
3238
3239 UNINST=0
3240 VERBINST=1
3241
3242 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3243 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3244
3245 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3246 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
3247 -e 'print "=over 4";' \
3248 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3249 -e 'print "=back";'
3250
3251 UNINSTALL =   $(PERL) -MExtUtils::Install \
3252 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3253 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3254 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3255 };
3256
3257     return join "", @m;
3258 }
3259
3260 =item tool_xsubpp (o)
3261
3262 Determines typemaps, xsubpp version, prototype behaviour.
3263
3264 =cut
3265
3266 sub tool_xsubpp {
3267     my($self) = shift;
3268     return "" unless $self->needs_linking;
3269     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3270     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3271     if( $self->{TYPEMAPS} ){
3272         my $typemap;
3273         foreach $typemap (@{$self->{TYPEMAPS}}){
3274                 if( ! -f  $typemap ){
3275                         warn "Typemap $typemap not found.\n";
3276                 }
3277                 else{
3278                         push(@tmdeps,  $typemap);
3279                 }
3280         }
3281     }
3282     push(@tmdeps, "typemap") if -f "typemap";
3283     my(@tmargs) = map("-typemap $_", @tmdeps);
3284     if( exists $self->{XSOPT} ){
3285         unshift( @tmargs, $self->{XSOPT} );
3286     }
3287
3288
3289     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3290
3291     # What are the correct thresholds for version 1 && 2 Paul?
3292     if ( $xsubpp_version > 1.923 ){
3293         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3294     } else {
3295         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3296             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3297         Your version of xsubpp is $xsubpp_version and cannot handle this.
3298         Please upgrade to a more recent version of xsubpp.
3299 };
3300         } else {
3301             $self->{XSPROTOARG} = "";
3302         }
3303     }
3304
3305     $xsubpp = $self->{CAPI} ? "xsubpp -object_capi" : "xsubpp";
3306
3307     return qq{
3308 XSUBPPDIR = $xsdir
3309 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3310 XSPROTOARG = $self->{XSPROTOARG}
3311 XSUBPPDEPS = @tmdeps
3312 XSUBPPARGS = @tmargs
3313 };
3314 };
3315
3316 sub xsubpp_version
3317 {
3318     my($self,$xsubpp) = @_;
3319     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3320
3321     my ($version) ;
3322
3323     # try to figure out the version number of the xsubpp on the system
3324
3325     # first try the -v flag, introduced in 1.921 & 2.000a2
3326
3327     return "" unless $self->needs_linking;
3328
3329     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3330     print "Running $command\n" if $Verbose >= 2;
3331     $version = `$command` ;
3332     warn "Running '$command' exits with status " . ($?>>8) if $?;
3333     chop $version ;
3334
3335     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3336
3337     # nope, then try something else
3338
3339     my $counter = '000';
3340     my ($file) = 'temp' ;
3341     $counter++ while -e "$file$counter"; # don't overwrite anything
3342     $file .= $counter;
3343
3344     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3345     print F <<EOM ;
3346 MODULE = fred PACKAGE = fred
3347
3348 int
3349 fred(a)
3350         int     a;
3351 EOM
3352
3353     close F ;
3354
3355     $command = "$self->{PERL} $xsubpp $file 2>&1";
3356     print "Running $command\n" if $Verbose >= 2;
3357     my $text = `$command` ;
3358     warn "Running '$command' exits with status " . ($?>>8) if $?;
3359     unlink $file ;
3360
3361     # gets 1.2 -> 1.92 and 2.000a1
3362     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3363
3364     # it is either 1.0 or 1.1
3365     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3366
3367     # none of the above, so 1.0
3368     return $Xsubpp_Version = "1.0" ;
3369 }
3370
3371 =item top_targets (o)
3372
3373 Defines the targets all, subdirs, config, and O_FILES
3374
3375 =cut
3376
3377 sub top_targets {
3378 # --- Target Sections ---
3379
3380     my($self) = shift;
3381     my(@m);
3382     push @m, '
3383 #all :: config $(INST_PM) subdirs linkext manifypods
3384 ';
3385
3386     push @m, '
3387 all :: pure_all manifypods
3388         '.$self->{NOECHO}.'$(NOOP)
3389
3390           unless $self->{SKIPHASH}{'all'};
3391     
3392     push @m, '
3393 pure_all :: config pm_to_blib subdirs linkext
3394         '.$self->{NOECHO}.'$(NOOP)
3395
3396 subdirs :: $(MYEXTLIB)
3397         '.$self->{NOECHO}.'$(NOOP)
3398
3399 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3400         '.$self->{NOECHO}.'$(NOOP)
3401
3402 config :: $(INST_ARCHAUTODIR)/.exists
3403         '.$self->{NOECHO}.'$(NOOP)
3404
3405 config :: $(INST_AUTODIR)/.exists
3406         '.$self->{NOECHO}.'$(NOOP)
3407 ';
3408
3409     push @m, qq{
3410 config :: Version_check
3411         $self->{NOECHO}\$(NOOP)
3412
3413 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
3414
3415     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3416
3417     if (%{$self->{MAN1PODS}}) {
3418         push @m, qq[
3419 config :: \$(INST_MAN1DIR)/.exists
3420         $self->{NOECHO}\$(NOOP)
3421
3422 ];
3423         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3424     }
3425     if (%{$self->{MAN3PODS}}) {
3426         push @m, qq[
3427 config :: \$(INST_MAN3DIR)/.exists
3428         $self->{NOECHO}\$(NOOP)
3429
3430 ];
3431         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3432     }
3433
3434     push @m, '
3435 $(O_FILES): $(H_FILES)
3436 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3437
3438     push @m, q{
3439 help:
3440         perldoc ExtUtils::MakeMaker
3441 };
3442
3443     push @m, q{
3444 Version_check:
3445         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3446                 -MExtUtils::MakeMaker=Version_check \
3447                 -e "Version_check('$(MM_VERSION)')"
3448 };
3449
3450     join('',@m);
3451 }
3452
3453 =item writedoc
3454
3455 Obsolete, depecated method. Not used since Version 5.21.
3456
3457 =cut
3458
3459 sub writedoc {
3460 # --- perllocal.pod section ---
3461     my($self,$what,$name,@attribs)=@_;
3462     my $time = localtime;
3463     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3464     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3465     print "\n\n=back\n\n";
3466 }
3467
3468 =item xs_c (o)
3469
3470 Defines the suffix rules to compile XS files to C.
3471
3472 =cut
3473
3474 sub xs_c {
3475     my($self) = shift;
3476     return '' unless $self->needs_linking();
3477     '
3478 .xs.c:
3479         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && $(MV) $*.tc $@
3480 ';
3481 }
3482
3483 =item xs_o (o)
3484
3485 Defines suffix rules to go from XS to object files directly. This is
3486 only intended for broken make implementations.
3487
3488 =cut
3489
3490 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3491     my($self) = shift;
3492     return '' unless $self->needs_linking();
3493     '
3494 .xs$(OBJ_EXT):
3495         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && $(MV) xstmp.c $*.c
3496         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3497 ';
3498 }
3499
3500 =item perl_archive
3501
3502 This is internal method that returns path to libperl.a equivalent
3503 to be linked to dynamic extensions. UNIX does not have one but OS2
3504 and Win32 do.
3505
3506 =cut 
3507
3508 sub perl_archive
3509 {
3510  return "";
3511 }
3512
3513 =item export_list
3514
3515 This is internal method that returns name of a file that is
3516 passed to linker to define symbols to be exported.
3517 UNIX does not have one but OS2 and Win32 do.
3518
3519 =cut 
3520
3521 sub export_list
3522 {
3523  return "";
3524 }
3525
3526
3527 1;
3528
3529 =back
3530
3531 =head1 SEE ALSO
3532
3533 L<ExtUtils::MakeMaker>
3534
3535 =cut
3536
3537 __END__