This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to ExtUtils::MakeMaker 6.28
[perl5.git] / lib / ExtUtils / MM_Any.pm
1 package ExtUtils::MM_Any;
2
3 use strict;
4 use vars qw($VERSION @ISA);
5 $VERSION = '0.13';
6
7 use File::Spec;
8 BEGIN { @ISA = qw(File::Spec); }
9
10 # We need $Verbose
11 use ExtUtils::MakeMaker qw($Verbose);
12
13 use ExtUtils::MakeMaker::Config;
14
15
16 # So we don't have to keep calling the methods over and over again,
17 # we have these globals to cache the values.  Faster and shrtr.
18 my $Curdir  = __PACKAGE__->curdir;
19 my $Rootdir = __PACKAGE__->rootdir;
20 my $Updir   = __PACKAGE__->updir;
21
22
23 =head1 NAME
24
25 ExtUtils::MM_Any - Platform-agnostic MM methods
26
27 =head1 SYNOPSIS
28
29   FOR INTERNAL USE ONLY!
30
31   package ExtUtils::MM_SomeOS;
32
33   # Temporarily, you have to subclass both.  Put MM_Any first.
34   require ExtUtils::MM_Any;
35   require ExtUtils::MM_Unix;
36   @ISA = qw(ExtUtils::MM_Any ExtUtils::Unix);
37
38 =head1 DESCRIPTION
39
40 B<FOR INTERNAL USE ONLY!>
41
42 ExtUtils::MM_Any is a superclass for the ExtUtils::MM_* set of
43 modules.  It contains methods which are either inherently
44 cross-platform or are written in a cross-platform manner.
45
46 Subclass off of ExtUtils::MM_Any I<and> ExtUtils::MM_Unix.  This is a
47 temporary solution.
48
49 B<THIS MAY BE TEMPORARY!>
50
51
52 =head1 METHODS
53
54 Any methods marked I<Abstract> must be implemented by subclasses.
55
56
57 =head2 Cross-platform helper methods
58
59 These are methods which help writing cross-platform code.
60
61
62
63 =head3 os_flavor  I<Abstract>
64
65     my @os_flavor = $mm->os_flavor;
66
67 @os_flavor is the style of operating system this is, usually
68 corresponding to the MM_*.pm file we're using.  
69
70 The first element of @os_flavor is the major family (ie. Unix,
71 Windows, VMS, OS/2, etc...) and the rest are sub families.
72
73 Some examples:
74
75     Cygwin98       ('Unix',  'Cygwin', 'Cygwin9x')
76     Windows NT     ('Win32', 'WinNT')
77     Win98          ('Win32', 'Win9x')
78     Linux          ('Unix',  'Linux')
79     MacOS X        ('Unix',  'Darwin', 'MacOS', 'MacOS X')
80     OS/2           ('OS/2')
81
82 This is used to write code for styles of operating system.  
83 See os_flavor_is() for use.
84
85
86 =head3 os_flavor_is
87
88     my $is_this_flavor = $mm->os_flavor_is($this_flavor);
89     my $is_this_flavor = $mm->os_flavor_is(@one_of_these_flavors);
90
91 Checks to see if the current operating system is one of the given flavors.
92
93 This is useful for code like:
94
95     if( $mm->os_flavor_is('Unix') ) {
96         $out = `foo 2>&1`;
97     }
98     else {
99         $out = `foo`;
100     }
101
102 =cut
103
104 sub os_flavor_is {
105     my $self = shift;
106     my %flavors = map { ($_ => 1) } $self->os_flavor;
107     return (grep { $flavors{$_} } @_) ? 1 : 0;
108 }
109
110
111 =head3 split_command
112
113     my @cmds = $MM->split_command($cmd, @args);
114
115 Most OS have a maximum command length they can execute at once.  Large
116 modules can easily generate commands well past that limit.  Its
117 necessary to split long commands up into a series of shorter commands.
118
119 C<split_command> will return a series of @cmds each processing part of
120 the args.  Collectively they will process all the arguments.  Each
121 individual line in @cmds will not be longer than the
122 $self->max_exec_len being careful to take into account macro expansion.
123
124 $cmd should include any switches and repeated initial arguments.
125
126 If no @args are given, no @cmds will be returned.
127
128 Pairs of arguments will always be preserved in a single command, this
129 is a heuristic for things like pm_to_blib and pod2man which work on
130 pairs of arguments.  This makes things like this safe:
131
132     $self->split_command($cmd, %pod2man);
133
134
135 =cut
136
137 sub split_command {
138     my($self, $cmd, @args) = @_;
139
140     my @cmds = ();
141     return(@cmds) unless @args;
142
143     # If the command was given as a here-doc, there's probably a trailing
144     # newline.
145     chomp $cmd;
146
147     # set aside 20% for macro expansion.
148     my $len_left = int($self->max_exec_len * 0.80);
149     $len_left -= length $self->_expand_macros($cmd);
150
151     do {
152         my $arg_str = '';
153         my @next_args;
154         while( @next_args = splice(@args, 0, 2) ) {
155             # Two at a time to preserve pairs.
156             my $next_arg_str = "\t  ". join ' ', @next_args, "\n";
157
158             if( !length $arg_str ) {
159                 $arg_str .= $next_arg_str
160             }
161             elsif( length($arg_str) + length($next_arg_str) > $len_left ) {
162                 unshift @args, @next_args;
163                 last;
164             }
165             else {
166                 $arg_str .= $next_arg_str;
167             }
168         }
169         chop $arg_str;
170
171         push @cmds, $self->escape_newlines("$cmd \n$arg_str");
172     } while @args;
173
174     return @cmds;
175 }
176
177
178 sub _expand_macros {
179     my($self, $cmd) = @_;
180
181     $cmd =~ s{\$\((\w+)\)}{
182         defined $self->{$1} ? $self->{$1} : "\$($1)"
183     }e;
184     return $cmd;
185 }
186
187
188 =head3 echo
189
190     my @commands = $MM->echo($text);
191     my @commands = $MM->echo($text, $file);
192     my @commands = $MM->echo($text, $file, $appending);
193
194 Generates a set of @commands which print the $text to a $file.
195
196 If $file is not given, output goes to STDOUT.
197
198 If $appending is true the $file will be appended to rather than
199 overwritten.
200
201 =cut
202
203 sub echo {
204     my($self, $text, $file, $appending) = @_;
205     $appending ||= 0;
206
207     my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_) } 
208                split /\n/, $text;
209     if( $file ) {
210         my $redirect = $appending ? '>>' : '>';
211         $cmds[0] .= " $redirect $file";
212         $_ .= " >> $file" foreach @cmds[1..$#cmds];
213     }
214
215     return @cmds;
216 }
217
218
219 =head3 wraplist
220
221   my $args = $mm->wraplist(@list);
222
223 Takes an array of items and turns them into a well-formatted list of
224 arguments.  In most cases this is simply something like:
225
226     FOO \
227     BAR \
228     BAZ
229
230 =cut
231
232 sub wraplist {
233     my $self = shift;
234     return join " \\\n\t", @_;
235 }
236
237
238 =head3 cd  I<Abstract>
239
240   my $subdir_cmd = $MM->cd($subdir, @cmds);
241
242 This will generate a make fragment which runs the @cmds in the given
243 $dir.  The rough equivalent to this, except cross platform.
244
245   cd $subdir && $cmd
246
247 Currently $dir can only go down one level.  "foo" is fine.  "foo/bar" is
248 not.  "../foo" is right out.
249
250 The resulting $subdir_cmd has no leading tab nor trailing newline.  This
251 makes it easier to embed in a make string.  For example.
252
253       my $make = sprintf <<'CODE', $subdir_cmd;
254   foo :
255       $(ECHO) what
256       %s
257       $(ECHO) mouche
258   CODE
259
260
261 =head3 oneliner  I<Abstract>
262
263   my $oneliner = $MM->oneliner($perl_code);
264   my $oneliner = $MM->oneliner($perl_code, \@switches);
265
266 This will generate a perl one-liner safe for the particular platform
267 you're on based on the given $perl_code and @switches (a -e is
268 assumed) suitable for using in a make target.  It will use the proper
269 shell quoting and escapes.
270
271 $(PERLRUN) will be used as perl.
272
273 Any newlines in $perl_code will be escaped.  Leading and trailing
274 newlines will be stripped.  Makes this idiom much easier:
275
276     my $code = $MM->oneliner(<<'CODE', [...switches...]);
277 some code here
278 another line here
279 CODE
280
281 Usage might be something like:
282
283     # an echo emulation
284     $oneliner = $MM->oneliner('print "Foo\n"');
285     $make = '$oneliner > somefile';
286
287 All dollar signs must be doubled in the $perl_code if you expect them
288 to be interpreted normally, otherwise it will be considered a make
289 macro.  Also remember to quote make macros else it might be used as a
290 bareword.  For example:
291
292     # Assign the value of the $(VERSION_FROM) make macro to $vf.
293     $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"');
294
295 Its currently very simple and may be expanded sometime in the figure
296 to include more flexible code and switches.
297
298
299 =head3 quote_literal  I<Abstract>
300
301     my $safe_text = $MM->quote_literal($text);
302
303 This will quote $text so it is interpreted literally in the shell.
304
305 For example, on Unix this would escape any single-quotes in $text and
306 put single-quotes around the whole thing.
307
308
309 =head3 escape_newlines  I<Abstract>
310
311     my $escaped_text = $MM->escape_newlines($text);
312
313 Shell escapes newlines in $text.
314
315
316 =head3 max_exec_len  I<Abstract>
317
318     my $max_exec_len = $MM->max_exec_len;
319
320 Calculates the maximum command size the OS can exec.  Effectively,
321 this is the max size of a shell command line.
322
323 =for _private
324 $self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes.
325
326
327
328
329
330 =head2 Targets
331
332 These are methods which produce make targets.
333
334
335 =head3 all_target
336
337 Generate the default target 'all'.
338
339 =cut
340
341 sub all_target {
342     my $self = shift;
343
344     return <<'MAKE_EXT';
345 all :: pure_all
346         $(NOECHO) $(NOOP)
347 MAKE_EXT
348
349 }
350
351
352 =head3 blibdirs_target
353
354     my $make_frag = $mm->blibdirs_target;
355
356 Creates the blibdirs target which creates all the directories we use
357 in blib/.
358
359 The blibdirs.ts target is deprecated.  Depend on blibdirs instead.
360
361
362 =cut
363
364 sub blibdirs_target {
365     my $self = shift;
366
367     my @dirs = map { uc "\$(INST_$_)" } qw(libdir archlib
368                                            autodir archautodir
369                                            bin script
370                                            man1dir man3dir
371                                           );
372
373     my @exists = map { $_.'$(DFSEP).exists' } @dirs;
374
375     my $make = sprintf <<'MAKE', join(' ', @exists);
376 blibdirs : %s
377         $(NOECHO) $(NOOP)
378
379 # Backwards compat with 6.18 through 6.25
380 blibdirs.ts : blibdirs
381         $(NOECHO) $(NOOP)
382
383 MAKE
384
385     $make .= $self->dir_target(@dirs);
386
387     return $make;
388 }
389
390
391 =head3 clean (o)
392
393 Defines the clean target.
394
395 =cut
396
397 sub clean {
398 # --- Cleanup and Distribution Sections ---
399
400     my($self, %attribs) = @_;
401     my @m;
402     push(@m, '
403 # Delete temporary files but do not touch installed files. We don\'t delete
404 # the Makefile here so a later make realclean still has a makefile to use.
405
406 clean :: clean_subdirs
407 ');
408
409     my @files = values %{$self->{XS}}; # .c files from *.xs files
410     my @dirs  = qw(blib);
411
412     # Normally these are all under blib but they might have been
413     # redefined.
414     # XXX normally this would be a good idea, but the Perl core sets
415     # INST_LIB = ../../lib rather than actually installing the files.
416     # So a "make clean" in an ext/ directory would blow away lib.
417     # Until the core is adjusted let's leave this out.
418 #     push @dirs, qw($(INST_ARCHLIB) $(INST_LIB)
419 #                    $(INST_BIN) $(INST_SCRIPT)
420 #                    $(INST_MAN1DIR) $(INST_MAN3DIR)
421 #                    $(INST_LIBDIR) $(INST_ARCHLIBDIR) $(INST_AUTODIR) 
422 #                    $(INST_STATIC) $(INST_DYNAMIC) $(INST_BOOT)
423 #                 );
424                   
425
426     if( $attribs{FILES} ) {
427         # Use @dirs because we don't know what's in here.
428         push @dirs, ref $attribs{FILES}                ?
429                         @{$attribs{FILES}}             :
430                         split /\s+/, $attribs{FILES}   ;
431     }
432
433     push(@files, qw[$(MAKE_APERL_FILE) 
434                     perlmain.c tmon.out mon.out so_locations 
435                     blibdirs.ts pm_to_blib pm_to_blib.ts
436                     *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
437                     $(BOOTSTRAP) $(BASEEXT).bso
438                     $(BASEEXT).def lib$(BASEEXT).def
439                     $(BASEEXT).exp $(BASEEXT).x
440                    ]);
441
442     push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'));
443     push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.ld'));
444
445     # core files
446     push(@files, qw[core core.*perl.*.? *perl.core]);
447     push(@files, map { "core." . "[0-9]"x$_ } (1..5));
448
449     # OS specific things to clean up.  Use @dirs since we don't know
450     # what might be in here.
451     push @dirs, $self->extra_clean_files;
452
453     # Occasionally files are repeated several times from different sources
454     { my(%f) = map { ($_ => 1) } @files; @files = keys %f; }
455     { my(%d) = map { ($_ => 1) } @dirs;  @dirs  = keys %d; }
456
457     push @m, map "\t$_\n", $self->split_command('- $(RM_F)',  @files);
458     push @m, map "\t$_\n", $self->split_command('- $(RM_RF)', @dirs);
459
460     # Leave Makefile.old around for realclean
461     push @m, <<'MAKE';
462         - $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)
463 MAKE
464
465     push(@m, "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
466
467     join("", @m);
468 }
469
470
471 =head3 clean_subdirs_target
472
473   my $make_frag = $MM->clean_subdirs_target;
474
475 Returns the clean_subdirs target.  This is used by the clean target to
476 call clean on any subdirectories which contain Makefiles.
477
478 =cut
479
480 sub clean_subdirs_target {
481     my($self) = shift;
482
483     # No subdirectories, no cleaning.
484     return <<'NOOP_FRAG' unless @{$self->{DIR}};
485 clean_subdirs :
486         $(NOECHO) $(NOOP)
487 NOOP_FRAG
488
489
490     my $clean = "clean_subdirs :\n";
491
492     for my $dir (@{$self->{DIR}}) {
493         my $subclean = $self->oneliner(sprintf <<'CODE', $dir);
494 chdir '%s';  system '$(MAKE) clean' if -f '$(FIRST_MAKEFILE)';
495 CODE
496
497         $clean .= "\t$subclean\n";
498     }
499
500     return $clean;
501 }
502
503
504 =head3 dir_target
505
506     my $make_frag = $mm->dir_target(@directories);
507
508 Generates targets to create the specified directories and set its
509 permission to 0755.
510
511 Because depending on a directory to just ensure it exists doesn't work
512 too well (the modified time changes too often) dir_target() creates a
513 .exists file in the created directory.  It is this you should depend on.
514 For portability purposes you should use the $(DIRFILESEP) macro rather
515 than a '/' to seperate the directory from the file.
516
517     yourdirectory$(DIRFILESEP).exists
518
519 =cut
520
521 sub dir_target {
522     my($self, @dirs) = @_;
523
524     my $make = '';
525     foreach my $dir (@dirs) {
526         $make .= sprintf <<'MAKE', ($dir) x 7;
527 %s$(DFSEP).exists :: Makefile.PL
528         $(NOECHO) $(MKPATH) %s
529         $(NOECHO) $(CHMOD) 755 %s
530         $(NOECHO) $(TOUCH) %s$(DFSEP).exists
531
532 MAKE
533
534     }
535
536     return $make;
537 }
538
539
540 =head3 distdir
541
542 Defines the scratch directory target that will hold the distribution
543 before tar-ing (or shar-ing).
544
545 =cut
546
547 # For backwards compatibility.
548 *dist_dir = *distdir;
549
550 sub distdir {
551     my($self) = shift;
552
553     my $meta_target = $self->{NO_META} ? '' : 'distmeta';
554     my $sign_target = !$self->{SIGN}   ? '' : 'distsignature';
555
556     return sprintf <<'MAKE_FRAG', $meta_target, $sign_target;
557 create_distdir :
558         $(RM_RF) $(DISTVNAME)
559         $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
560                 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
561
562 distdir : create_distdir %s %s
563         $(NOECHO) $(NOOP)
564
565 MAKE_FRAG
566
567 }
568
569
570 =head3 dist_test
571
572 Defines a target that produces the distribution in the
573 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
574 subdirectory.
575
576 =cut
577
578 sub dist_test {
579     my($self) = shift;
580
581     my $mpl_args = join " ", map qq["$_"], @ARGV;
582
583     my $test = $self->cd('$(DISTVNAME)',
584                          '$(ABSPERLRUN) Makefile.PL '.$mpl_args,
585                          '$(MAKE) $(PASTHRU)',
586                          '$(MAKE) test $(PASTHRU)'
587                         );
588
589     return sprintf <<'MAKE_FRAG', $test;
590 disttest : distdir
591         %s
592
593 MAKE_FRAG
594
595
596 }
597
598
599 =head3 dynamic (o)
600
601 Defines the dynamic target.
602
603 =cut
604
605 sub dynamic {
606 # --- Dynamic Loading Sections ---
607
608     my($self) = shift;
609     '
610 dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
611         $(NOECHO) $(NOOP)
612 ';
613 }
614
615
616 =head3 makemakerdflt_target
617
618   my $make_frag = $mm->makemakerdflt_target
619
620 Returns a make fragment with the makemakerdeflt_target specified.
621 This target is the first target in the Makefile, is the default target
622 and simply points off to 'all' just in case any make variant gets
623 confused or something gets snuck in before the real 'all' target.
624
625 =cut
626
627 sub makemakerdflt_target {
628     return <<'MAKE_FRAG';
629 makemakerdflt: all
630         $(NOECHO) $(NOOP)
631 MAKE_FRAG
632
633 }
634
635
636 =head3 manifypods_target
637
638   my $manifypods_target = $self->manifypods_target;
639
640 Generates the manifypods target.  This target generates man pages from
641 all POD files in MAN1PODS and MAN3PODS.
642
643 =cut
644
645 sub manifypods_target {
646     my($self) = shift;
647
648     my $man1pods      = '';
649     my $man3pods      = '';
650     my $dependencies  = '';
651
652     # populate manXpods & dependencies:
653     foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) {
654         $dependencies .= " \\\n\t$name";
655     }
656
657     foreach my $name (keys %{$self->{MAN3PODS}}) {
658         $dependencies .= " \\\n\t$name"
659     }
660
661     my $manify = <<END;
662 manifypods : pure_all $dependencies
663 END
664
665     my @man_cmds;
666     foreach my $section (qw(1 3)) {
667         my $pods = $self->{"MAN${section}PODS"};
668         push @man_cmds, $self->split_command(<<CMD, %$pods);
669         \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW)
670 CMD
671     }
672
673     $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
674     $manify .= join '', map { "$_\n" } @man_cmds;
675
676     return $manify;
677 }
678
679
680 =head3 metafile_target
681
682     my $target = $mm->metafile_target;
683
684 Generate the metafile target.
685
686 Writes the file META.yml YAML encoded meta-data about the module in
687 the distdir.  The format follows Module::Build's as closely as
688 possible.  Additionally, we include:
689
690     version_from
691     installdirs
692
693 =cut
694
695 sub metafile_target {
696     my $self = shift;
697
698     return <<'MAKE_FRAG' if $self->{NO_META};
699 metafile:
700         $(NOECHO) $(NOOP)
701 MAKE_FRAG
702
703     my $prereq_pm = '';
704     foreach my $mod ( sort { lc $a cmp lc $b } keys %{$self->{PREREQ_PM}} ) {
705         my $ver = $self->{PREREQ_PM}{$mod};
706         $prereq_pm .= sprintf "    %-30s %s\n", "$mod:", $ver;
707     }
708
709     my $meta = <<YAML;
710 # http://module-build.sourceforge.net/META-spec.html
711 #XXXXXXX This is a prototype!!!  It will change in the future!!! XXXXX#
712 name:         $self->{DISTNAME}
713 version:      $self->{VERSION}
714 version_from: $self->{VERSION_FROM}
715 installdirs:  $self->{INSTALLDIRS}
716 requires:
717 $prereq_pm
718 distribution_type: module
719 generated_by: ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION
720 YAML
721
722     my @write_meta = $self->echo($meta, 'META_new.yml');
723
724     return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta);
725 metafile : create_distdir
726         $(NOECHO) $(ECHO) Generating META.yml
727         %s
728         -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml
729 MAKE_FRAG
730
731 }
732
733
734 =head3 distmeta_target
735
736     my $make_frag = $mm->distmeta_target;
737
738 Generates the distmeta target to add META.yml to the MANIFEST in the
739 distdir.
740
741 =cut
742
743 sub distmeta_target {
744     my $self = shift;
745
746     my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
747 eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } 
748     or print "Could not add META.yml to MANIFEST: $${'@'}\n"
749 CODE
750
751     my $add_meta_to_distdir = $self->cd('$(DISTVNAME)', $add_meta);
752
753     return sprintf <<'MAKE', $add_meta_to_distdir;
754 distmeta : create_distdir metafile
755         $(NOECHO) %s
756
757 MAKE
758
759 }
760
761
762 =head3 realclean (o)
763
764 Defines the realclean target.
765
766 =cut
767
768 sub realclean {
769     my($self, %attribs) = @_;
770
771     my @dirs  = qw($(DISTVNAME));
772     my @files = qw($(FIRST_MAKEFILE) $(MAKEFILE_OLD));
773
774     # Special exception for the perl core where INST_* is not in blib.
775     # This cleans up the files built from the ext/ directory (all XS).
776     if( $self->{PERL_CORE} ) {
777         push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR));
778         push @files, values %{$self->{PM}};
779     }
780
781     if( $self->has_link_code ){
782         push @files, qw($(OBJECT));
783     }
784
785     if( $attribs{FILES} ) {
786         if( ref $attribs{FILES} ) {
787             push @dirs, @{ $attribs{FILES} };
788         }
789         else {
790             push @dirs, split /\s+/, $attribs{FILES};
791         }
792     }
793
794     # Occasionally files are repeated several times from different sources
795     { my(%f) = map { ($_ => 1) } @files;  @files = keys %f; }
796     { my(%d) = map { ($_ => 1) } @dirs;   @dirs  = keys %d; }
797
798     my $rm_cmd  = join "\n\t", map { "$_" } 
799                     $self->split_command('- $(RM_F)',  @files);
800     my $rmf_cmd = join "\n\t", map { "$_" } 
801                     $self->split_command('- $(RM_RF)', @dirs);
802
803     my $m = sprintf <<'MAKE', $rm_cmd, $rmf_cmd;
804 # Delete temporary files (via clean) and also delete dist files
805 realclean purge ::  clean realclean_subdirs
806         %s
807         %s
808 MAKE
809
810     $m .= "\t$attribs{POSTOP}\n" if $attribs{POSTOP};
811
812     return $m;
813 }
814
815
816 =head3 realclean_subdirs_target
817
818   my $make_frag = $MM->realclean_subdirs_target;
819
820 Returns the realclean_subdirs target.  This is used by the realclean
821 target to call realclean on any subdirectories which contain Makefiles.
822
823 =cut
824
825 sub realclean_subdirs_target {
826     my $self = shift;
827
828     return <<'NOOP_FRAG' unless @{$self->{DIR}};
829 realclean_subdirs :
830         $(NOECHO) $(NOOP)
831 NOOP_FRAG
832
833     my $rclean = "realclean_subdirs :\n";
834
835     foreach my $dir (@{$self->{DIR}}) {
836         foreach my $makefile ('$(MAKEFILE_OLD)', '$(FIRST_MAKEFILE)' ) {
837             my $subrclean .= $self->oneliner(sprintf <<'CODE', $dir, ($makefile) x 2);
838 chdir '%s';  system '$(MAKE) $(USEMAKEFILE) %s realclean' if -f '%s';
839 CODE
840
841             $rclean .= sprintf <<'RCLEAN', $subrclean;
842         - %s
843 RCLEAN
844
845         }
846     }
847
848     return $rclean;
849 }
850
851
852 =head3 signature_target
853
854     my $target = $mm->signature_target;
855
856 Generate the signature target.
857
858 Writes the file SIGNATURE with "cpansign -s".
859
860 =cut
861
862 sub signature_target {
863     my $self = shift;
864
865     return <<'MAKE_FRAG';
866 signature :
867         cpansign -s
868 MAKE_FRAG
869
870 }
871
872
873 =head3 distsignature_target
874
875     my $make_frag = $mm->distsignature_target;
876
877 Generates the distsignature target to add SIGNATURE to the MANIFEST in the
878 distdir.
879
880 =cut
881
882 sub distsignature_target {
883     my $self = shift;
884
885     my $add_sign = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
886 eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } 
887     or print "Could not add SIGNATURE to MANIFEST: $${'@'}\n"
888 CODE
889
890     my $sign_dist        = $self->cd('$(DISTVNAME)' => 'cpansign -s');
891
892     # cpansign -s complains if SIGNATURE is in the MANIFEST yet does not
893     # exist
894     my $touch_sig        = $self->cd('$(DISTVNAME)' => '$(TOUCH) SIGNATURE');
895     my $add_sign_to_dist = $self->cd('$(DISTVNAME)' => $add_sign );
896
897     return sprintf <<'MAKE', $add_sign_to_dist, $touch_sig, $sign_dist
898 distsignature : create_distdir
899         $(NOECHO) %s
900         $(NOECHO) %s
901         %s
902
903 MAKE
904
905 }
906
907
908 =head3 special_targets
909
910   my $make_frag = $mm->special_targets
911
912 Returns a make fragment containing any targets which have special
913 meaning to make.  For example, .SUFFIXES and .PHONY.
914
915 =cut
916
917 sub special_targets {
918     my $make_frag = <<'MAKE_FRAG';
919 .SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
920
921 .PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir
922
923 MAKE_FRAG
924
925     $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT};
926 .NO_CONFIG_REC: Makefile
927
928 MAKE_FRAG
929
930     return $make_frag;
931 }
932
933
934
935
936 =head2 Init methods
937
938 Methods which help initialize the MakeMaker object and macros.
939
940
941 =head3 init_INST
942
943     $mm->init_INST;
944
945 Called by init_main.  Sets up all INST_* variables except those related
946 to XS code.  Those are handled in init_xs.
947
948 =cut
949
950 sub init_INST {
951     my($self) = shift;
952
953     $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
954     $self->{INST_BIN}     ||= $self->catdir($Curdir,'blib','bin');
955
956     # INST_LIB typically pre-set if building an extension after
957     # perl has been built and installed. Setting INST_LIB allows
958     # you to build directly into, say $Config{privlibexp}.
959     unless ($self->{INST_LIB}){
960         if ($self->{PERL_CORE}) {
961             if (defined $Cross::platform) {
962                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = 
963                   $self->catdir($self->{PERL_LIB},"..","xlib",
964                                      $Cross::platform);
965             }
966             else {
967                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
968             }
969         } else {
970             $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
971         }
972     }
973
974     my @parentdir = split(/::/, $self->{PARENT_NAME});
975     $self->{INST_LIBDIR}      = $self->catdir('$(INST_LIB)',     @parentdir);
976     $self->{INST_ARCHLIBDIR}  = $self->catdir('$(INST_ARCHLIB)', @parentdir);
977     $self->{INST_AUTODIR}     = $self->catdir('$(INST_LIB)', 'auto', 
978                                               '$(FULLEXT)');
979     $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
980                                               '$(FULLEXT)');
981
982     $self->{INST_SCRIPT}  ||= $self->catdir($Curdir,'blib','script');
983
984     $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
985     $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
986
987     return 1;
988 }
989
990
991 =head3 init_INSTALL
992
993     $mm->init_INSTALL;
994
995 Called by init_main.  Sets up all INSTALL_* variables (except
996 INSTALLDIRS) and *PREFIX.
997
998 =cut
999
1000 sub init_INSTALL {
1001     my($self) = shift;
1002
1003     if( $self->{ARGS}{INSTALLBASE} and $self->{ARGS}{PREFIX} ) {
1004         die "Only one of PREFIX or INSTALLBASE can be given.  Not both.\n";
1005     }
1006
1007     if( $self->{ARGS}{INSTALLBASE} ) {
1008         $self->init_INSTALL_from_INSTALLBASE;
1009     }
1010     else {
1011         $self->init_INSTALL_from_PREFIX;
1012     }
1013 }
1014
1015
1016 =head3 init_INSTALL_from_PREFIX
1017
1018   $mm->init_INSTALL_from_PREFIX;
1019
1020 =cut
1021
1022 sub init_INSTALL_from_PREFIX {
1023     my $self = shift;
1024
1025     $self->init_lib2arch;
1026
1027     # There are often no Config.pm defaults for these new man variables so 
1028     # we fall back to the old behavior which is to use installman*dir
1029     foreach my $num (1, 3) {
1030         my $k = 'installsiteman'.$num.'dir';
1031
1032         $self->{uc $k} ||= uc "\$(installman${num}dir)"
1033           unless $Config{$k};
1034     }
1035
1036     foreach my $num (1, 3) {
1037         my $k = 'installvendorman'.$num.'dir';
1038
1039         unless( $Config{$k} ) {
1040             $self->{uc $k}  ||= $Config{usevendorprefix}
1041                               ? uc "\$(installman${num}dir)"
1042                               : '';
1043         }
1044     }
1045
1046     $self->{INSTALLSITEBIN} ||= '$(INSTALLBIN)'
1047       unless $Config{installsitebin};
1048
1049     unless( $Config{installvendorbin} ) {
1050         $self->{INSTALLVENDORBIN} ||= $Config{usevendorprefix} 
1051                                     ? $Config{installbin}
1052                                     : '';
1053     }
1054
1055
1056     my $iprefix = $Config{installprefixexp} || $Config{installprefix} || 
1057                   $Config{prefixexp}        || $Config{prefix} || '';
1058     my $vprefix = $Config{usevendorprefix}  ? $Config{vendorprefixexp} : '';
1059     my $sprefix = $Config{siteprefixexp}    || '';
1060
1061     # 5.005_03 doesn't have a siteprefix.
1062     $sprefix = $iprefix unless $sprefix;
1063
1064
1065     $self->{PREFIX}       ||= '';
1066
1067     if( $self->{PREFIX} ) {
1068         @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
1069           ('$(PREFIX)') x 3;
1070     }
1071     else {
1072         $self->{PERLPREFIX}   ||= $iprefix;
1073         $self->{SITEPREFIX}   ||= $sprefix;
1074         $self->{VENDORPREFIX} ||= $vprefix;
1075
1076         # Lots of MM extension authors like to use $(PREFIX) so we
1077         # put something sensible in there no matter what.
1078         $self->{PREFIX} = '$('.uc $self->{INSTALLDIRS}.'PREFIX)';
1079     }
1080
1081     my $arch    = $Config{archname};
1082     my $version = $Config{version};
1083
1084     # default style
1085     my $libstyle = $Config{installstyle} || 'lib/perl5';
1086     my $manstyle = '';
1087
1088     if( $self->{LIBSTYLE} ) {
1089         $libstyle = $self->{LIBSTYLE};
1090         $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
1091     }
1092
1093     # Some systems, like VOS, set installman*dir to '' if they can't
1094     # read man pages.
1095     for my $num (1, 3) {
1096         $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
1097           unless $Config{'installman'.$num.'dir'};
1098     }
1099
1100     my %bin_layouts = 
1101     (
1102         bin         => { s => $iprefix,
1103                          t => 'perl',
1104                          d => 'bin' },
1105         vendorbin   => { s => $vprefix,
1106                          t => 'vendor',
1107                          d => 'bin' },
1108         sitebin     => { s => $sprefix,
1109                          t => 'site',
1110                          d => 'bin' },
1111         script      => { s => $iprefix,
1112                          t => 'perl',
1113                          d => 'bin' },
1114     );
1115     
1116     my %man_layouts =
1117     (
1118         man1dir         => { s => $iprefix,
1119                              t => 'perl',
1120                              d => 'man/man1',
1121                              style => $manstyle, },
1122         siteman1dir     => { s => $sprefix,
1123                              t => 'site',
1124                              d => 'man/man1',
1125                              style => $manstyle, },
1126         vendorman1dir   => { s => $vprefix,
1127                              t => 'vendor',
1128                              d => 'man/man1',
1129                              style => $manstyle, },
1130
1131         man3dir         => { s => $iprefix,
1132                              t => 'perl',
1133                              d => 'man/man3',
1134                              style => $manstyle, },
1135         siteman3dir     => { s => $sprefix,
1136                              t => 'site',
1137                              d => 'man/man3',
1138                              style => $manstyle, },
1139         vendorman3dir   => { s => $vprefix,
1140                              t => 'vendor',
1141                              d => 'man/man3',
1142                              style => $manstyle, },
1143     );
1144
1145     my %lib_layouts =
1146     (
1147         privlib     => { s => $iprefix,
1148                          t => 'perl',
1149                          d => '',
1150                          style => $libstyle, },
1151         vendorlib   => { s => $vprefix,
1152                          t => 'vendor',
1153                          d => '',
1154                          style => $libstyle, },
1155         sitelib     => { s => $sprefix,
1156                          t => 'site',
1157                          d => 'site_perl',
1158                          style => $libstyle, },
1159         
1160         archlib     => { s => $iprefix,
1161                          t => 'perl',
1162                          d => "$version/$arch",
1163                          style => $libstyle },
1164         vendorarch  => { s => $vprefix,
1165                          t => 'vendor',
1166                          d => "$version/$arch",
1167                          style => $libstyle },
1168         sitearch    => { s => $sprefix,
1169                          t => 'site',
1170                          d => "site_perl/$version/$arch",
1171                          style => $libstyle },
1172     );
1173
1174
1175     # Special case for LIB.
1176     if( $self->{LIB} ) {
1177         foreach my $var (keys %lib_layouts) {
1178             my $Installvar = uc "install$var";
1179
1180             if( $var =~ /arch/ ) {
1181                 $self->{$Installvar} ||= 
1182                   $self->catdir($self->{LIB}, $Config{archname});
1183             }
1184             else {
1185                 $self->{$Installvar} ||= $self->{LIB};
1186             }
1187         }
1188     }
1189
1190     my %type2prefix = ( perl    => 'PERLPREFIX',
1191                         site    => 'SITEPREFIX',
1192                         vendor  => 'VENDORPREFIX'
1193                       );
1194
1195     my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
1196     while( my($var, $layout) = each(%layouts) ) {
1197         my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
1198         my $r = '$('.$type2prefix{$t}.')';
1199
1200         print STDERR "Prefixing $var\n" if $Verbose >= 2;
1201
1202         my $installvar = "install$var";
1203         my $Installvar = uc $installvar;
1204         next if $self->{$Installvar};
1205
1206         $d = "$style/$d" if $style;
1207         $self->prefixify($installvar, $s, $r, $d);
1208
1209         print STDERR "  $Installvar == $self->{$Installvar}\n" 
1210           if $Verbose >= 2;
1211     }
1212
1213     # Generate these if they weren't figured out.
1214     $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
1215     $self->{VENDORLIBEXP}  ||= $self->{INSTALLVENDORLIB};
1216
1217     return 1;
1218 }
1219
1220
1221 =head3 init_from_INSTALLBASE
1222
1223     $mm->init_from_INSTALLBASE
1224
1225 =cut
1226
1227 my %map = (
1228            lib      => [qw(lib perl5)],
1229            arch     => [('lib', 'perl5', $Config{archname})],
1230            bin      => [qw(bin)],
1231            man1dir  => [qw(man man1)],
1232            man3dir  => [qw(man man3)]
1233           );
1234 $map{script} = $map{bin};
1235
1236 sub init_INSTALL_from_INSTALLBASE {
1237     my $self = shift;
1238
1239     @{$self}{qw(PREFIX VENDORPREFIX SITEPREFIX PERLPREFIX)} = 
1240                                                          '$(INSTALLBASE)';
1241
1242     my %install;
1243     foreach my $thing (keys %map) {
1244         foreach my $dir (('', 'SITE', 'VENDOR')) {
1245             my $uc_thing = uc $thing;
1246             my $key = "INSTALL".$dir.$uc_thing;
1247
1248             $install{$key} ||= 
1249               $self->catdir('$(INSTALLBASE)', @{$map{$thing}});
1250         }
1251     }
1252
1253     # Adjust for variable quirks.
1254     $install{INSTALLARCHLIB} ||= delete $install{INSTALLARCH};
1255     $install{INSTALLPRIVLIB} ||= delete $install{INSTALLLIB};
1256     delete @install{qw(INSTALLVENDORSCRIPT INSTALLSITESCRIPT)};
1257
1258     foreach my $key (keys %install) {
1259         $self->{$key} ||= $install{$key};
1260     }
1261
1262     return 1;
1263 }
1264
1265
1266 =head3 init_VERSION  I<Abstract>
1267
1268     $mm->init_VERSION
1269
1270 Initialize macros representing versions of MakeMaker and other tools
1271
1272 MAKEMAKER: path to the MakeMaker module.
1273
1274 MM_VERSION: ExtUtils::MakeMaker Version
1275
1276 MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards 
1277              compat)
1278
1279 VERSION: version of your module
1280
1281 VERSION_MACRO: which macro represents the version (usually 'VERSION')
1282
1283 VERSION_SYM: like version but safe for use as an RCS revision number
1284
1285 DEFINE_VERSION: -D line to set the module version when compiling
1286
1287 XS_VERSION: version in your .xs file.  Defaults to $(VERSION)
1288
1289 XS_VERSION_MACRO: which macro represents the XS version.
1290
1291 XS_DEFINE_VERSION: -D line to set the xs version when compiling.
1292
1293 Called by init_main.
1294
1295 =cut
1296
1297 sub init_VERSION {
1298     my($self) = shift;
1299
1300     $self->{MAKEMAKER}  = $ExtUtils::MakeMaker::Filename;
1301     $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION;
1302     $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision;
1303     $self->{VERSION_FROM} ||= '';
1304
1305     if ($self->{VERSION_FROM}){
1306         $self->{VERSION} = $self->parse_version($self->{VERSION_FROM});
1307         if( $self->{VERSION} eq 'undef' ) {
1308             require Carp;
1309             Carp::carp("WARNING: Setting VERSION via file ".
1310                        "'$self->{VERSION_FROM}' failed\n");
1311         }
1312     }
1313
1314     # strip blanks
1315     if (defined $self->{VERSION}) {
1316         $self->{VERSION} =~ s/^\s+//;
1317         $self->{VERSION} =~ s/\s+$//;
1318     }
1319     else {
1320         $self->{VERSION} = '';
1321     }
1322
1323
1324     $self->{VERSION_MACRO}  = 'VERSION';
1325     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1326     $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"';
1327
1328
1329     # Graham Barr and Paul Marquess had some ideas how to ensure
1330     # version compatibility between the *.pm file and the
1331     # corresponding *.xs file. The bottomline was, that we need an
1332     # XS_VERSION macro that defaults to VERSION:
1333     $self->{XS_VERSION} ||= $self->{VERSION};
1334
1335     $self->{XS_VERSION_MACRO}  = 'XS_VERSION';
1336     $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"';
1337
1338 }
1339
1340
1341 =head3 init_others  I<Abstract>
1342
1343     $MM->init_others();
1344
1345 Initializes the macro definitions used by tools_other() and places them
1346 in the $MM object.
1347
1348 If there is no description, its the same as the parameter to
1349 WriteMakefile() documented in ExtUtils::MakeMaker.
1350
1351 Defines at least these macros.
1352
1353   Macro             Description
1354
1355   NOOP              Do nothing
1356   NOECHO            Tell make not to display the command itself
1357
1358   MAKEFILE
1359   FIRST_MAKEFILE
1360   MAKEFILE_OLD
1361   MAKE_APERL_FILE   File used by MAKE_APERL
1362
1363   SHELL             Program used to run
1364                     shell commands
1365
1366   ECHO              Print text adding a newline on the end
1367   RM_F              Remove a file 
1368   RM_RF             Remove a directory          
1369   TOUCH             Update a file's timestamp   
1370   TEST_F            Test for a file's existence 
1371   CP                Copy a file                 
1372   MV                Move a file                 
1373   CHMOD             Change permissions on a     
1374                     file
1375
1376   UMASK_NULL        Nullify umask
1377   DEV_NULL          Supress all command output
1378
1379
1380 =head3 init_DIRFILESEP  I<Abstract>
1381
1382   $MM->init_DIRFILESEP;
1383   my $dirfilesep = $MM->{DIRFILESEP};
1384
1385 Initializes the DIRFILESEP macro which is the seperator between the
1386 directory and filename in a filepath.  ie. / on Unix, \ on Win32 and
1387 nothing on VMS.
1388
1389 For example:
1390
1391     # instead of $(INST_ARCHAUTODIR)/extralibs.ld
1392     $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld
1393
1394 Something of a hack but it prevents a lot of code duplication between
1395 MM_* variants.
1396
1397 Do not use this as a seperator between directories.  Some operating
1398 systems use different seperators between subdirectories as between
1399 directories and filenames (for example:  VOLUME:[dir1.dir2]file on VMS).
1400
1401 =head3 init_linker  I<Abstract>
1402
1403     $mm->init_linker;
1404
1405 Initialize macros which have to do with linking.
1406
1407 PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic
1408 extensions.
1409
1410 PERL_ARCHIVE_AFTER: path to a library which should be put on the
1411 linker command line I<after> the external libraries to be linked to
1412 dynamic extensions.  This may be needed if the linker is one-pass, and
1413 Perl includes some overrides for C RTL functions, such as malloc().
1414
1415 EXPORT_LIST: name of a file that is passed to linker to define symbols
1416 to be exported.
1417
1418 Some OSes do not need these in which case leave it blank.
1419
1420
1421 =head3 init_platform
1422
1423     $mm->init_platform
1424
1425 Initialize any macros which are for platform specific use only.
1426
1427 A typical one is the version number of your OS specific mocule.
1428 (ie. MM_Unix_VERSION or MM_VMS_VERSION).
1429
1430 =cut
1431
1432 sub init_platform {
1433     return '';
1434 }
1435
1436
1437
1438
1439
1440 =head2 Tools
1441
1442 A grab bag of methods to generate specific macros and commands.
1443
1444
1445
1446 =head3 manifypods
1447
1448 Defines targets and routines to translate the pods into manpages and
1449 put them into the INST_* directories.
1450
1451 =cut
1452
1453 sub manifypods {
1454     my $self          = shift;
1455
1456     my $POD2MAN_macro = $self->POD2MAN_macro();
1457     my $manifypods_target = $self->manifypods_target();
1458
1459     return <<END_OF_TARGET;
1460
1461 $POD2MAN_macro
1462
1463 $manifypods_target
1464
1465 END_OF_TARGET
1466
1467 }
1468
1469
1470 =head3 POD2MAN_macro
1471
1472   my $pod2man_macro = $self->POD2MAN_macro
1473
1474 Returns a definition for the POD2MAN macro.  This is a program
1475 which emulates the pod2man utility.  You can add more switches to the
1476 command by simply appending them on the macro.
1477
1478 Typical usage:
1479
1480     $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) podfile1 man_page1 ...
1481
1482 =cut
1483
1484 sub POD2MAN_macro {
1485     my $self = shift;
1486
1487 # Need the trailing '--' so perl stops gobbling arguments and - happens
1488 # to be an alternative end of line seperator on VMS so we quote it
1489     return <<'END_OF_DEF';
1490 POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
1491 POD2MAN = $(POD2MAN_EXE)
1492 END_OF_DEF
1493 }
1494
1495
1496 =head3 test_via_harness
1497
1498   my $command = $mm->test_via_harness($perl, $tests);
1499
1500 Returns a $command line which runs the given set of $tests with
1501 Test::Harness and the given $perl.
1502
1503 Used on the t/*.t files.
1504
1505 =cut
1506
1507 sub test_via_harness {
1508     my($self, $perl, $tests) = @_;
1509
1510     return qq{\t$perl "-MExtUtils::Command::MM" }.
1511            qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n};
1512 }
1513
1514 =head3 test_via_script
1515
1516   my $command = $mm->test_via_script($perl, $script);
1517
1518 Returns a $command line which just runs a single test without
1519 Test::Harness.  No checks are done on the results, they're just
1520 printed.
1521
1522 Used for test.pl, since they don't always follow Test::Harness
1523 formatting.
1524
1525 =cut
1526
1527 sub test_via_script {
1528     my($self, $perl, $script) = @_;
1529     return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n};
1530 }
1531
1532
1533 =head3 tool_autosplit
1534
1535 Defines a simple perl call that runs autosplit. May be deprecated by
1536 pm_to_blib soon.
1537
1538 =cut
1539
1540 sub tool_autosplit {
1541     my($self, %attribs) = @_;
1542
1543     my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' 
1544                                   : '';
1545
1546     my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen);
1547 use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)
1548 PERL_CODE
1549
1550     return sprintf <<'MAKE_FRAG', $asplit;
1551 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
1552 AUTOSPLITFILE = %s
1553
1554 MAKE_FRAG
1555
1556 }
1557
1558
1559
1560
1561 =head2 File::Spec wrappers
1562
1563 ExtUtils::MM_Any is a subclass of File::Spec.  The methods noted here
1564 override File::Spec.
1565
1566
1567
1568 =head3 catfile
1569
1570 File::Spec <= 0.83 has a bug where the file part of catfile is not
1571 canonicalized.  This override fixes that bug.
1572
1573 =cut
1574
1575 sub catfile {
1576     my $self = shift;
1577     return $self->canonpath($self->SUPER::catfile(@_));
1578 }
1579
1580
1581
1582 =head2 Misc
1583
1584 Methods I can't really figure out where they should go yet.
1585
1586
1587 =head3 find_tests
1588
1589   my $test = $mm->find_tests;
1590
1591 Returns a string suitable for feeding to the shell to return all
1592 tests in t/*.t.
1593
1594 =cut
1595
1596 sub find_tests {
1597     my($self) = shift;
1598     return -d 't' ? 't/*.t' : '';
1599 }
1600
1601
1602 =head3 extra_clean_files
1603
1604     my @files_to_clean = $MM->extra_clean_files;
1605
1606 Returns a list of OS specific files to be removed in the clean target in
1607 addition to the usual set.
1608
1609 =cut
1610
1611 # An empty method here tickled a perl 5.8.1 bug and would return its object.
1612 sub extra_clean_files { 
1613     return;
1614 }
1615
1616
1617 =head3 installvars
1618
1619     my @installvars = $mm->installvars;
1620
1621 A list of all the INSTALL* variables without the INSTALL prefix.  Useful
1622 for iteration or building related variable sets.
1623
1624 =cut
1625
1626 sub installvars {
1627     return qw(PRIVLIB SITELIB  VENDORLIB
1628               ARCHLIB SITEARCH VENDORARCH
1629               BIN     SITEBIN  VENDORBIN
1630               SCRIPT
1631               MAN1DIR SITEMAN1DIR VENDORMAN1DIR
1632               MAN3DIR SITEMAN3DIR VENDORMAN3DIR
1633              );
1634 }
1635
1636
1637 =head3 libscan
1638
1639   my $wanted = $self->libscan($path);
1640
1641 Takes a path to a file or dir and returns an empty string if we don't
1642 want to include this file in the library.  Otherwise it returns the
1643 the $path unchanged.
1644
1645 Mainly used to exclude version control administrative directories from
1646 installation.
1647
1648 =cut
1649
1650 sub libscan {
1651     my($self,$path) = @_;
1652     my($dirs,$file) = ($self->splitpath($path))[1,2];
1653     return '' if grep /^(?:RCS|CVS|SCCS|\.svn|_darcs)$/, 
1654                      $self->splitdir($dirs), $file;
1655
1656     return $path;
1657 }
1658
1659
1660 =head3 platform_constants
1661
1662     my $make_frag = $mm->platform_constants
1663
1664 Returns a make fragment defining all the macros initialized in
1665 init_platform() rather than put them in constants().
1666
1667 =cut
1668
1669 sub platform_constants {
1670     return '';
1671 }
1672
1673
1674 =head1 AUTHOR
1675
1676 Michael G Schwern <schwern@pobox.com> and the denizens of
1677 makemaker@perl.org with code from ExtUtils::MM_Unix and
1678 ExtUtils::MM_Win32.
1679
1680
1681 =cut
1682
1683 1;