Re: lib, ext, cpan and dist [PATCH] (take 2)
[perl.git] / ext / ExtUtils-MakeMaker / lib / ExtUtils / MM_Any.pm
1 package ExtUtils::MM_Any;
2
3 use strict;
4 our $VERSION = '6.55_02';
5
6 use Carp;
7 use File::Spec;
8 use File::Basename;
9 BEGIN { our @ISA = qw(File::Spec); }
10
11 # We need $Verbose
12 use ExtUtils::MakeMaker qw($Verbose);
13
14 use ExtUtils::MakeMaker::Config;
15
16
17 # So we don't have to keep calling the methods over and over again,
18 # we have these globals to cache the values.  Faster and shrtr.
19 my $Curdir  = __PACKAGE__->curdir;
20 my $Rootdir = __PACKAGE__->rootdir;
21 my $Updir   = __PACKAGE__->updir;
22
23
24 =head1 NAME
25
26 ExtUtils::MM_Any - Platform-agnostic MM methods
27
28 =head1 SYNOPSIS
29
30   FOR INTERNAL USE ONLY!
31
32   package ExtUtils::MM_SomeOS;
33
34   # Temporarily, you have to subclass both.  Put MM_Any first.
35   require ExtUtils::MM_Any;
36   require ExtUtils::MM_Unix;
37   @ISA = qw(ExtUtils::MM_Any ExtUtils::Unix);
38
39 =head1 DESCRIPTION
40
41 B<FOR INTERNAL USE ONLY!>
42
43 ExtUtils::MM_Any is a superclass for the ExtUtils::MM_* set of
44 modules.  It contains methods which are either inherently
45 cross-platform or are written in a cross-platform manner.
46
47 Subclass off of ExtUtils::MM_Any I<and> ExtUtils::MM_Unix.  This is a
48 temporary solution.
49
50 B<THIS MAY BE TEMPORARY!>
51
52
53 =head1 METHODS
54
55 Any methods marked I<Abstract> must be implemented by subclasses.
56
57
58 =head2 Cross-platform helper methods
59
60 These are methods which help writing cross-platform code.
61
62
63
64 =head3 os_flavor  I<Abstract>
65
66     my @os_flavor = $mm->os_flavor;
67
68 @os_flavor is the style of operating system this is, usually
69 corresponding to the MM_*.pm file we're using.  
70
71 The first element of @os_flavor is the major family (ie. Unix,
72 Windows, VMS, OS/2, etc...) and the rest are sub families.
73
74 Some examples:
75
76     Cygwin98       ('Unix',  'Cygwin', 'Cygwin9x')
77     Windows        ('Win32')
78     Win98          ('Win32', 'Win9x')
79     Linux          ('Unix',  'Linux')
80     MacOS X        ('Unix',  'Darwin', 'MacOS', 'MacOS X')
81     OS/2           ('OS/2')
82
83 This is used to write code for styles of operating system.  
84 See os_flavor_is() for use.
85
86
87 =head3 os_flavor_is
88
89     my $is_this_flavor = $mm->os_flavor_is($this_flavor);
90     my $is_this_flavor = $mm->os_flavor_is(@one_of_these_flavors);
91
92 Checks to see if the current operating system is one of the given flavors.
93
94 This is useful for code like:
95
96     if( $mm->os_flavor_is('Unix') ) {
97         $out = `foo 2>&1`;
98     }
99     else {
100         $out = `foo`;
101     }
102
103 =cut
104
105 sub os_flavor_is {
106     my $self = shift;
107     my %flavors = map { ($_ => 1) } $self->os_flavor;
108     return (grep { $flavors{$_} } @_) ? 1 : 0;
109 }
110
111
112 =head3 can_load_xs
113
114     my $can_load_xs = $self->can_load_xs;
115
116 Returns true if we have the ability to load XS.
117
118 This is important because miniperl, used to build XS modules in the
119 core, can not load XS.
120
121 =cut
122
123 sub can_load_xs {
124     return defined &DynaLoader::boot_DynaLoader ? 1 : 0;
125 }
126
127
128 =head3 split_command
129
130     my @cmds = $MM->split_command($cmd, @args);
131
132 Most OS have a maximum command length they can execute at once.  Large
133 modules can easily generate commands well past that limit.  Its
134 necessary to split long commands up into a series of shorter commands.
135
136 C<split_command> will return a series of @cmds each processing part of
137 the args.  Collectively they will process all the arguments.  Each
138 individual line in @cmds will not be longer than the
139 $self->max_exec_len being careful to take into account macro expansion.
140
141 $cmd should include any switches and repeated initial arguments.
142
143 If no @args are given, no @cmds will be returned.
144
145 Pairs of arguments will always be preserved in a single command, this
146 is a heuristic for things like pm_to_blib and pod2man which work on
147 pairs of arguments.  This makes things like this safe:
148
149     $self->split_command($cmd, %pod2man);
150
151
152 =cut
153
154 sub split_command {
155     my($self, $cmd, @args) = @_;
156
157     my @cmds = ();
158     return(@cmds) unless @args;
159
160     # If the command was given as a here-doc, there's probably a trailing
161     # newline.
162     chomp $cmd;
163
164     # set aside 30% for macro expansion.
165     my $len_left = int($self->max_exec_len * 0.70);
166     $len_left -= length $self->_expand_macros($cmd);
167
168     do {
169         my $arg_str = '';
170         my @next_args;
171         while( @next_args = splice(@args, 0, 2) ) {
172             # Two at a time to preserve pairs.
173             my $next_arg_str = "\t  ". join ' ', @next_args, "\n";
174
175             if( !length $arg_str ) {
176                 $arg_str .= $next_arg_str
177             }
178             elsif( length($arg_str) + length($next_arg_str) > $len_left ) {
179                 unshift @args, @next_args;
180                 last;
181             }
182             else {
183                 $arg_str .= $next_arg_str;
184             }
185         }
186         chop $arg_str;
187
188         push @cmds, $self->escape_newlines("$cmd \n$arg_str");
189     } while @args;
190
191     return @cmds;
192 }
193
194
195 sub _expand_macros {
196     my($self, $cmd) = @_;
197
198     $cmd =~ s{\$\((\w+)\)}{
199         defined $self->{$1} ? $self->{$1} : "\$($1)"
200     }e;
201     return $cmd;
202 }
203
204
205 =head3 echo
206
207     my @commands = $MM->echo($text);
208     my @commands = $MM->echo($text, $file);
209     my @commands = $MM->echo($text, $file, $appending);
210
211 Generates a set of @commands which print the $text to a $file.
212
213 If $file is not given, output goes to STDOUT.
214
215 If $appending is true the $file will be appended to rather than
216 overwritten.
217
218 =cut
219
220 sub echo {
221     my($self, $text, $file, $appending) = @_;
222     $appending ||= 0;
223
224     my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_) } 
225                split /\n/, $text;
226     if( $file ) {
227         my $redirect = $appending ? '>>' : '>';
228         $cmds[0] .= " $redirect $file";
229         $_ .= " >> $file" foreach @cmds[1..$#cmds];
230     }
231
232     return @cmds;
233 }
234
235
236 =head3 wraplist
237
238   my $args = $mm->wraplist(@list);
239
240 Takes an array of items and turns them into a well-formatted list of
241 arguments.  In most cases this is simply something like:
242
243     FOO \
244     BAR \
245     BAZ
246
247 =cut
248
249 sub wraplist {
250     my $self = shift;
251     return join " \\\n\t", @_;
252 }
253
254
255 =head3 maketext_filter
256
257     my $filter_make_text = $mm->maketext_filter($make_text);
258
259 The text of the Makefile is run through this method before writing to
260 disk.  It allows systems a chance to make portability fixes to the
261 Makefile.
262
263 By default it does nothing.
264
265 This method is protected and not intended to be called outside of
266 MakeMaker.
267
268 =cut
269
270 sub maketext_filter { return $_[1] }
271
272
273 =head3 cd  I<Abstract>
274
275   my $subdir_cmd = $MM->cd($subdir, @cmds);
276
277 This will generate a make fragment which runs the @cmds in the given
278 $dir.  The rough equivalent to this, except cross platform.
279
280   cd $subdir && $cmd
281
282 Currently $dir can only go down one level.  "foo" is fine.  "foo/bar" is
283 not.  "../foo" is right out.
284
285 The resulting $subdir_cmd has no leading tab nor trailing newline.  This
286 makes it easier to embed in a make string.  For example.
287
288       my $make = sprintf <<'CODE', $subdir_cmd;
289   foo :
290       $(ECHO) what
291       %s
292       $(ECHO) mouche
293   CODE
294
295
296 =head3 oneliner  I<Abstract>
297
298   my $oneliner = $MM->oneliner($perl_code);
299   my $oneliner = $MM->oneliner($perl_code, \@switches);
300
301 This will generate a perl one-liner safe for the particular platform
302 you're on based on the given $perl_code and @switches (a -e is
303 assumed) suitable for using in a make target.  It will use the proper
304 shell quoting and escapes.
305
306 $(PERLRUN) will be used as perl.
307
308 Any newlines in $perl_code will be escaped.  Leading and trailing
309 newlines will be stripped.  Makes this idiom much easier:
310
311     my $code = $MM->oneliner(<<'CODE', [...switches...]);
312 some code here
313 another line here
314 CODE
315
316 Usage might be something like:
317
318     # an echo emulation
319     $oneliner = $MM->oneliner('print "Foo\n"');
320     $make = '$oneliner > somefile';
321
322 All dollar signs must be doubled in the $perl_code if you expect them
323 to be interpreted normally, otherwise it will be considered a make
324 macro.  Also remember to quote make macros else it might be used as a
325 bareword.  For example:
326
327     # Assign the value of the $(VERSION_FROM) make macro to $vf.
328     $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"');
329
330 Its currently very simple and may be expanded sometime in the figure
331 to include more flexible code and switches.
332
333
334 =head3 quote_literal  I<Abstract>
335
336     my $safe_text = $MM->quote_literal($text);
337
338 This will quote $text so it is interpreted literally in the shell.
339
340 For example, on Unix this would escape any single-quotes in $text and
341 put single-quotes around the whole thing.
342
343
344 =head3 escape_newlines  I<Abstract>
345
346     my $escaped_text = $MM->escape_newlines($text);
347
348 Shell escapes newlines in $text.
349
350
351 =head3 max_exec_len  I<Abstract>
352
353     my $max_exec_len = $MM->max_exec_len;
354
355 Calculates the maximum command size the OS can exec.  Effectively,
356 this is the max size of a shell command line.
357
358 =for _private
359 $self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes.
360
361
362 =head3 make
363
364     my $make = $MM->make;
365
366 Returns the make variant we're generating the Makefile for.  This attempts
367 to do some normalization on the information from %Config or the user.
368
369 =cut
370
371 sub make {
372     my $self = shift;
373
374     my $make = lc $self->{MAKE};
375
376     # Truncate anything like foomake6 to just foomake.
377     $make =~ s/^(\w+make).*/$1/;
378
379     # Turn gnumake into gmake.
380     $make =~ s/^gnu/g/;
381
382     return $make;
383 }
384
385
386 =head2 Targets
387
388 These are methods which produce make targets.
389
390
391 =head3 all_target
392
393 Generate the default target 'all'.
394
395 =cut
396
397 sub all_target {
398     my $self = shift;
399
400     return <<'MAKE_EXT';
401 all :: pure_all
402         $(NOECHO) $(NOOP)
403 MAKE_EXT
404
405 }
406
407
408 =head3 blibdirs_target
409
410     my $make_frag = $mm->blibdirs_target;
411
412 Creates the blibdirs target which creates all the directories we use
413 in blib/.
414
415 The blibdirs.ts target is deprecated.  Depend on blibdirs instead.
416
417
418 =cut
419
420 sub blibdirs_target {
421     my $self = shift;
422
423     my @dirs = map { uc "\$(INST_$_)" } qw(libdir archlib
424                                            autodir archautodir
425                                            bin script
426                                            man1dir man3dir
427                                           );
428
429     my @exists = map { $_.'$(DFSEP).exists' } @dirs;
430
431     my $make = sprintf <<'MAKE', join(' ', @exists);
432 blibdirs : %s
433         $(NOECHO) $(NOOP)
434
435 # Backwards compat with 6.18 through 6.25
436 blibdirs.ts : blibdirs
437         $(NOECHO) $(NOOP)
438
439 MAKE
440
441     $make .= $self->dir_target(@dirs);
442
443     return $make;
444 }
445
446
447 =head3 clean (o)
448
449 Defines the clean target.
450
451 =cut
452
453 sub clean {
454 # --- Cleanup and Distribution Sections ---
455
456     my($self, %attribs) = @_;
457     my @m;
458     push(@m, '
459 # Delete temporary files but do not touch installed files. We don\'t delete
460 # the Makefile here so a later make realclean still has a makefile to use.
461
462 clean :: clean_subdirs
463 ');
464
465     my @files = values %{$self->{XS}}; # .c files from *.xs files
466     my @dirs  = qw(blib);
467
468     # Normally these are all under blib but they might have been
469     # redefined.
470     # XXX normally this would be a good idea, but the Perl core sets
471     # INST_LIB = ../../lib rather than actually installing the files.
472     # So a "make clean" in an ext/ directory would blow away lib.
473     # Until the core is adjusted let's leave this out.
474 #     push @dirs, qw($(INST_ARCHLIB) $(INST_LIB)
475 #                    $(INST_BIN) $(INST_SCRIPT)
476 #                    $(INST_MAN1DIR) $(INST_MAN3DIR)
477 #                    $(INST_LIBDIR) $(INST_ARCHLIBDIR) $(INST_AUTODIR) 
478 #                    $(INST_STATIC) $(INST_DYNAMIC) $(INST_BOOT)
479 #                 );
480                   
481
482     if( $attribs{FILES} ) {
483         # Use @dirs because we don't know what's in here.
484         push @dirs, ref $attribs{FILES}                ?
485                         @{$attribs{FILES}}             :
486                         split /\s+/, $attribs{FILES}   ;
487     }
488
489     push(@files, qw[$(MAKE_APERL_FILE) 
490                     perlmain.c tmon.out mon.out so_locations 
491                     blibdirs.ts pm_to_blib pm_to_blib.ts
492                     *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
493                     $(BOOTSTRAP) $(BASEEXT).bso
494                     $(BASEEXT).def lib$(BASEEXT).def
495                     $(BASEEXT).exp $(BASEEXT).x
496                    ]);
497
498     push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'));
499     push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.ld'));
500
501     # core files
502     push(@files, qw[core core.*perl.*.? *perl.core]);
503     push(@files, map { "core." . "[0-9]"x$_ } (1..5));
504
505     # OS specific things to clean up.  Use @dirs since we don't know
506     # what might be in here.
507     push @dirs, $self->extra_clean_files;
508
509     # Occasionally files are repeated several times from different sources
510     { my(%f) = map { ($_ => 1) } @files; @files = keys %f; }
511     { my(%d) = map { ($_ => 1) } @dirs;  @dirs  = keys %d; }
512
513     push @m, map "\t$_\n", $self->split_command('- $(RM_F)',  @files);
514     push @m, map "\t$_\n", $self->split_command('- $(RM_RF)', @dirs);
515
516     # Leave Makefile.old around for realclean
517     push @m, <<'MAKE';
518         - $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)
519 MAKE
520
521     push(@m, "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
522
523     join("", @m);
524 }
525
526
527 =head3 clean_subdirs_target
528
529   my $make_frag = $MM->clean_subdirs_target;
530
531 Returns the clean_subdirs target.  This is used by the clean target to
532 call clean on any subdirectories which contain Makefiles.
533
534 =cut
535
536 sub clean_subdirs_target {
537     my($self) = shift;
538
539     # No subdirectories, no cleaning.
540     return <<'NOOP_FRAG' unless @{$self->{DIR}};
541 clean_subdirs :
542         $(NOECHO) $(NOOP)
543 NOOP_FRAG
544
545
546     my $clean = "clean_subdirs :\n";
547
548     for my $dir (@{$self->{DIR}}) {
549         my $subclean = $self->oneliner(sprintf <<'CODE', $dir);
550 chdir '%s';  system '$(MAKE) clean' if -f '$(FIRST_MAKEFILE)';
551 CODE
552
553         $clean .= "\t$subclean\n";
554     }
555
556     return $clean;
557 }
558
559
560 =head3 dir_target
561
562     my $make_frag = $mm->dir_target(@directories);
563
564 Generates targets to create the specified directories and set its
565 permission to PERM_DIR.
566
567 Because depending on a directory to just ensure it exists doesn't work
568 too well (the modified time changes too often) dir_target() creates a
569 .exists file in the created directory.  It is this you should depend on.
570 For portability purposes you should use the $(DIRFILESEP) macro rather
571 than a '/' to seperate the directory from the file.
572
573     yourdirectory$(DIRFILESEP).exists
574
575 =cut
576
577 sub dir_target {
578     my($self, @dirs) = @_;
579
580     my $make = '';
581     foreach my $dir (@dirs) {
582         $make .= sprintf <<'MAKE', ($dir) x 7;
583 %s$(DFSEP).exists :: Makefile.PL
584         $(NOECHO) $(MKPATH) %s
585         $(NOECHO) $(CHMOD) $(PERM_DIR) %s
586         $(NOECHO) $(TOUCH) %s$(DFSEP).exists
587
588 MAKE
589
590     }
591
592     return $make;
593 }
594
595
596 =head3 distdir
597
598 Defines the scratch directory target that will hold the distribution
599 before tar-ing (or shar-ing).
600
601 =cut
602
603 # For backwards compatibility.
604 *dist_dir = *distdir;
605
606 sub distdir {
607     my($self) = shift;
608
609     my $meta_target = $self->{NO_META} ? '' : 'distmeta';
610     my $sign_target = !$self->{SIGN}   ? '' : 'distsignature';
611
612     return sprintf <<'MAKE_FRAG', $meta_target, $sign_target;
613 create_distdir :
614         $(RM_RF) $(DISTVNAME)
615         $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
616                 -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
617
618 distdir : create_distdir %s %s
619         $(NOECHO) $(NOOP)
620
621 MAKE_FRAG
622
623 }
624
625
626 =head3 dist_test
627
628 Defines a target that produces the distribution in the
629 scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
630 subdirectory.
631
632 =cut
633
634 sub dist_test {
635     my($self) = shift;
636
637     my $mpl_args = join " ", map qq["$_"], @ARGV;
638
639     my $test = $self->cd('$(DISTVNAME)',
640                          '$(ABSPERLRUN) Makefile.PL '.$mpl_args,
641                          '$(MAKE) $(PASTHRU)',
642                          '$(MAKE) test $(PASTHRU)'
643                         );
644
645     return sprintf <<'MAKE_FRAG', $test;
646 disttest : distdir
647         %s
648
649 MAKE_FRAG
650
651
652 }
653
654
655 =head3 dynamic (o)
656
657 Defines the dynamic target.
658
659 =cut
660
661 sub dynamic {
662 # --- Dynamic Loading Sections ---
663
664     my($self) = shift;
665     '
666 dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
667         $(NOECHO) $(NOOP)
668 ';
669 }
670
671
672 =head3 makemakerdflt_target
673
674   my $make_frag = $mm->makemakerdflt_target
675
676 Returns a make fragment with the makemakerdeflt_target specified.
677 This target is the first target in the Makefile, is the default target
678 and simply points off to 'all' just in case any make variant gets
679 confused or something gets snuck in before the real 'all' target.
680
681 =cut
682
683 sub makemakerdflt_target {
684     return <<'MAKE_FRAG';
685 makemakerdflt : all
686         $(NOECHO) $(NOOP)
687 MAKE_FRAG
688
689 }
690
691
692 =head3 manifypods_target
693
694   my $manifypods_target = $self->manifypods_target;
695
696 Generates the manifypods target.  This target generates man pages from
697 all POD files in MAN1PODS and MAN3PODS.
698
699 =cut
700
701 sub manifypods_target {
702     my($self) = shift;
703
704     my $man1pods      = '';
705     my $man3pods      = '';
706     my $dependencies  = '';
707
708     # populate manXpods & dependencies:
709     foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) {
710         $dependencies .= " \\\n\t$name";
711     }
712
713     my $manify = <<END;
714 manifypods : pure_all $dependencies
715 END
716
717     my @man_cmds;
718     foreach my $section (qw(1 3)) {
719         my $pods = $self->{"MAN${section}PODS"};
720         push @man_cmds, $self->split_command(<<CMD, %$pods);
721         \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW)
722 CMD
723     }
724
725     $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
726     $manify .= join '', map { "$_\n" } @man_cmds;
727
728     return $manify;
729 }
730
731
732 =head3 metafile_target
733
734     my $target = $mm->metafile_target;
735
736 Generate the metafile target.
737
738 Writes the file META.yml YAML encoded meta-data about the module in
739 the distdir.  The format follows Module::Build's as closely as
740 possible.
741
742 =cut
743
744 sub metafile_target {
745     my $self = shift;
746
747     return <<'MAKE_FRAG' if $self->{NO_META};
748 metafile :
749         $(NOECHO) $(NOOP)
750 MAKE_FRAG
751
752     my @metadata   = $self->metafile_data(
753         $self->{META_ADD}   || {},
754         $self->{META_MERGE} || {},
755     );
756     my $meta       = $self->metafile_file(@metadata);
757     my @write_meta = $self->echo($meta, 'META_new.yml');
758
759     return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta);
760 metafile : create_distdir
761         $(NOECHO) $(ECHO) Generating META.yml
762         %s
763         -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml
764 MAKE_FRAG
765
766 }
767
768
769 =begin private
770
771 =head3 _sort_pairs
772
773     my @pairs = _sort_pairs($sort_sub, \%hash);
774
775 Sorts the pairs of a hash based on keys ordered according 
776 to C<$sort_sub>.
777
778 =end private
779
780 =cut
781
782 sub _sort_pairs {
783     my $sort  = shift;
784     my $pairs = shift;
785     return map  { $_ => $pairs->{$_} }
786            sort $sort
787            keys %$pairs;
788 }
789
790
791 # Taken from Module::Build::Base
792 sub _hash_merge {
793     my ($self, $h, $k, $v) = @_;
794     if (ref $h->{$k} eq 'ARRAY') {
795         push @{$h->{$k}}, ref $v ? @$v : $v;
796     } elsif (ref $h->{$k} eq 'HASH') {
797         $self->_hash_merge($h->{$k}, $_, $v->{$_}) foreach keys %$v;
798     } else {
799         $h->{$k} = $v;
800     }
801 }
802
803
804 =head3 metafile_data
805
806     my @metadata_pairs = $mm->metafile_data(\%meta_add, \%meta_merge);
807
808 Returns the data which MakeMaker turns into the META.yml file.
809
810 Values of %meta_add will overwrite any existing metadata in those
811 keys.  %meta_merge will be merged with them.
812
813 =cut
814
815 sub metafile_data {
816     my $self = shift;
817     my($meta_add, $meta_merge) = @_;
818
819     # The order in which standard meta keys should be written.
820     my @meta_order = qw(
821         name
822         version
823         abstract
824         author
825         license
826         distribution_type
827
828         configure_requires
829         build_requires
830         requires
831
832         resources
833
834         provides
835         no_index
836
837         generated_by
838         meta-spec
839     );
840
841     # Check the original args so we can tell between the user setting it
842     # to an empty hash and it just being initialized.
843     my $configure_requires;
844     if( $self->{ARGS}{CONFIGURE_REQUIRES} ) {
845         $configure_requires = $self->{CONFIGURE_REQUIRES};
846     } else {
847         $configure_requires = {
848             'ExtUtils::MakeMaker'       => 0,
849         };
850     }
851     my $build_requires;
852     if( $self->{ARGS}{BUILD_REQUIRES} ) {
853         $build_requires = $self->{BUILD_REQUIRES};
854     } else {
855         $build_requires = {
856             'ExtUtils::MakeMaker'       => 0,
857         };
858     }
859
860     my %meta = (
861         name         => $self->{DISTNAME},
862         version      => $self->{VERSION},
863         abstract     => $self->{ABSTRACT},
864         license      => $self->{LICENSE} || 'unknown',
865         distribution_type => $self->{PM} ? 'module' : 'script',
866
867         configure_requires => $configure_requires,
868
869         build_requires => $build_requires,
870
871         no_index     => {
872             directory   => [qw(t inc)]
873         },
874
875         generated_by => "ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION",
876         'meta-spec'  => {
877             url         => 'http://module-build.sourceforge.net/META-spec-v1.4.html', 
878             version     => 1.4
879         },
880     );
881
882     # The author key is required and it takes a list.
883     $meta{author}   = defined $self->{AUTHOR}    ? [$self->{AUTHOR}] : [];
884
885     $meta{requires} = $self->{PREREQ_PM} if defined $self->{PREREQ_PM};
886     $meta{requires}{perl} = $self->{MIN_PERL_VERSION} if $self->{MIN_PERL_VERSION};
887
888     while( my($key, $val) = each %$meta_add ) {
889         $meta{$key} = $val;
890     }
891
892     while( my($key, $val) = each %$meta_merge ) {
893         $self->_hash_merge(\%meta, $key, $val);
894     }
895
896     my @meta_pairs;
897
898     # Put the standard keys first in the proper order.
899     for my $key (@meta_order) {
900         next unless exists $meta{$key};
901
902         push @meta_pairs, $key, delete $meta{$key};
903     }
904
905     # Then tack everything else onto the end, alpha sorted.
906     for my $key (sort {lc $a cmp lc $b} keys %meta) {
907         push @meta_pairs, $key, $meta{$key};
908     }
909
910     return @meta_pairs
911 }
912
913 =begin private
914
915 =head3 _dump_hash
916
917     $yaml = _dump_hash(\%options, %hash);
918
919 Implements a fake YAML dumper for a hash given
920 as a list of pairs. No quoting/escaping is done. Keys
921 are supposed to be strings. Values are undef, strings, 
922 hash refs or array refs of strings.
923
924 Supported options are:
925
926     delta => STR - indentation delta
927     use_header => BOOL - whether to include a YAML header
928     indent => STR - a string of spaces 
929           default: ''
930
931     max_key_length => INT - maximum key length used to align
932         keys and values of the same hash
933         default: 20
934     key_sort => CODE - a sort sub 
935             It may be undef, which means no sorting by keys
936         default: sub { lc $a cmp lc $b }
937
938     customs => HASH - special options for certain keys 
939            (whose values are hashes themselves)
940         may contain: max_key_length, key_sort, customs
941
942 =end private
943
944 =cut
945
946 sub _dump_hash {
947     croak "first argument should be a hash ref" unless ref $_[0] eq 'HASH';
948     my $options = shift;
949     my %hash = @_;
950
951     # Use a list to preserve order.
952     my @pairs;
953
954     my $k_sort 
955         = exists $options->{key_sort} ? $options->{key_sort} 
956                                       : sub { lc $a cmp lc $b };
957     if ($k_sort) {
958         croak "'key_sort' should be a coderef" unless ref $k_sort eq 'CODE';
959         @pairs = _sort_pairs($k_sort, \%hash);
960     } else { # list of pairs, no sorting
961         @pairs = @_;
962     }
963
964     my $yaml     = $options->{use_header} ? "--- #YAML:1.0\n" : '';
965     my $indent   = $options->{indent} || '';
966     my $k_length = min(
967         ($options->{max_key_length} || 20),
968         max(map { length($_) + 1 } grep { !ref $hash{$_} } keys %hash)
969     );
970     my $customs  = $options->{customs} || {};
971
972     # printf format for key
973     my $k_format = "%-${k_length}s";
974
975     while( @pairs ) {
976         my($key, $val) = splice @pairs, 0, 2;
977         $val = '~' unless defined $val;
978         if(ref $val eq 'HASH') {
979             if ( keys %$val ) {
980                 my %k_options = ( # options for recursive call
981                     delta => $options->{delta},
982                     use_header => 0,
983                     indent => $indent . $options->{delta},
984                 );
985                 if (exists $customs->{$key}) {
986                     my %k_custom = %{$customs->{$key}};
987                     foreach my $k qw(key_sort max_key_length customs) {
988                         $k_options{$k} = $k_custom{$k} if exists $k_custom{$k};
989                     }
990                 }
991                 $yaml .= $indent . "$key:\n" 
992                   . _dump_hash(\%k_options, %$val);
993             }
994             else {
995                 $yaml .= $indent . "$key:  {}\n";
996             }
997         }
998         elsif (ref $val eq 'ARRAY') {
999             if( @$val ) {
1000                 $yaml .= $indent . "$key:\n";
1001
1002                 for (@$val) {
1003                     croak "only nested arrays of non-refs are supported" if ref $_;
1004                     $yaml .= $indent . $options->{delta} . "- $_\n";
1005                 }
1006             }
1007             else {
1008                 $yaml .= $indent . "$key:  []\n";
1009             }
1010         }
1011         elsif( ref $val and !blessed($val) ) {
1012             croak "only nested hashes, arrays and objects are supported";
1013         }
1014         else {  # if it's an object, just stringify it
1015             $yaml .= $indent . sprintf "$k_format  %s\n", "$key:", $val;
1016         }
1017     };
1018
1019     return $yaml;
1020
1021 }
1022
1023 sub blessed {
1024     return eval { $_[0]->isa("UNIVERSAL"); };
1025 }
1026
1027 sub max {
1028     return (sort { $b <=> $a } @_)[0];
1029 }
1030
1031 sub min {
1032     return (sort { $a <=> $b } @_)[0];
1033 }
1034
1035 =head3 metafile_file
1036
1037     my $meta_yml = $mm->metafile_file(@metadata_pairs);
1038
1039 Turns the @metadata_pairs into YAML.
1040
1041 This method does not implement a complete YAML dumper, being limited
1042 to dump a hash with values which are strings, undef's or nested hashes
1043 and arrays of strings. No quoting/escaping is done.
1044
1045 =cut
1046
1047 sub metafile_file {
1048     my $self = shift;
1049
1050     my %dump_options = (
1051         use_header => 1, 
1052         delta      => ' ' x 4, 
1053         key_sort   => undef,
1054     );
1055     return _dump_hash(\%dump_options, @_);
1056
1057 }
1058
1059
1060 =head3 distmeta_target
1061
1062     my $make_frag = $mm->distmeta_target;
1063
1064 Generates the distmeta target to add META.yml to the MANIFEST in the
1065 distdir.
1066
1067 =cut
1068
1069 sub distmeta_target {
1070     my $self = shift;
1071
1072     my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
1073 eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } 
1074     or print "Could not add META.yml to MANIFEST: $${'@'}\n"
1075 CODE
1076
1077     my $add_meta_to_distdir = $self->cd('$(DISTVNAME)', $add_meta);
1078
1079     return sprintf <<'MAKE', $add_meta_to_distdir;
1080 distmeta : create_distdir metafile
1081         $(NOECHO) %s
1082
1083 MAKE
1084
1085 }
1086
1087
1088 =head3 realclean (o)
1089
1090 Defines the realclean target.
1091
1092 =cut
1093
1094 sub realclean {
1095     my($self, %attribs) = @_;
1096
1097     my @dirs  = qw($(DISTVNAME));
1098     my @files = qw($(FIRST_MAKEFILE) $(MAKEFILE_OLD));
1099
1100     # Special exception for the perl core where INST_* is not in blib.
1101     # This cleans up the files built from the ext/ directory (all XS).
1102     if( $self->{PERL_CORE} ) {
1103         push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR));
1104         push @files, values %{$self->{PM}};
1105     }
1106
1107     if( $self->has_link_code ){
1108         push @files, qw($(OBJECT));
1109     }
1110
1111     if( $attribs{FILES} ) {
1112         if( ref $attribs{FILES} ) {
1113             push @dirs, @{ $attribs{FILES} };
1114         }
1115         else {
1116             push @dirs, split /\s+/, $attribs{FILES};
1117         }
1118     }
1119
1120     # Occasionally files are repeated several times from different sources
1121     { my(%f) = map { ($_ => 1) } @files;  @files = keys %f; }
1122     { my(%d) = map { ($_ => 1) } @dirs;   @dirs  = keys %d; }
1123
1124     my $rm_cmd  = join "\n\t", map { "$_" } 
1125                     $self->split_command('- $(RM_F)',  @files);
1126     my $rmf_cmd = join "\n\t", map { "$_" } 
1127                     $self->split_command('- $(RM_RF)', @dirs);
1128
1129     my $m = sprintf <<'MAKE', $rm_cmd, $rmf_cmd;
1130 # Delete temporary files (via clean) and also delete dist files
1131 realclean purge ::  clean realclean_subdirs
1132         %s
1133         %s
1134 MAKE
1135
1136     $m .= "\t$attribs{POSTOP}\n" if $attribs{POSTOP};
1137
1138     return $m;
1139 }
1140
1141
1142 =head3 realclean_subdirs_target
1143
1144   my $make_frag = $MM->realclean_subdirs_target;
1145
1146 Returns the realclean_subdirs target.  This is used by the realclean
1147 target to call realclean on any subdirectories which contain Makefiles.
1148
1149 =cut
1150
1151 sub realclean_subdirs_target {
1152     my $self = shift;
1153
1154     return <<'NOOP_FRAG' unless @{$self->{DIR}};
1155 realclean_subdirs :
1156         $(NOECHO) $(NOOP)
1157 NOOP_FRAG
1158
1159     my $rclean = "realclean_subdirs :\n";
1160
1161     foreach my $dir (@{$self->{DIR}}) {
1162         foreach my $makefile ('$(MAKEFILE_OLD)', '$(FIRST_MAKEFILE)' ) {
1163             my $subrclean .= $self->oneliner(sprintf <<'CODE', $dir, ($makefile) x 2);
1164 chdir '%s';  system '$(MAKE) $(USEMAKEFILE) %s realclean' if -f '%s';
1165 CODE
1166
1167             $rclean .= sprintf <<'RCLEAN', $subrclean;
1168         - %s
1169 RCLEAN
1170
1171         }
1172     }
1173
1174     return $rclean;
1175 }
1176
1177
1178 =head3 signature_target
1179
1180     my $target = $mm->signature_target;
1181
1182 Generate the signature target.
1183
1184 Writes the file SIGNATURE with "cpansign -s".
1185
1186 =cut
1187
1188 sub signature_target {
1189     my $self = shift;
1190
1191     return <<'MAKE_FRAG';
1192 signature :
1193         cpansign -s
1194 MAKE_FRAG
1195
1196 }
1197
1198
1199 =head3 distsignature_target
1200
1201     my $make_frag = $mm->distsignature_target;
1202
1203 Generates the distsignature target to add SIGNATURE to the MANIFEST in the
1204 distdir.
1205
1206 =cut
1207
1208 sub distsignature_target {
1209     my $self = shift;
1210
1211     my $add_sign = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
1212 eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } 
1213     or print "Could not add SIGNATURE to MANIFEST: $${'@'}\n"
1214 CODE
1215
1216     my $sign_dist        = $self->cd('$(DISTVNAME)' => 'cpansign -s');
1217
1218     # cpansign -s complains if SIGNATURE is in the MANIFEST yet does not
1219     # exist
1220     my $touch_sig        = $self->cd('$(DISTVNAME)' => '$(TOUCH) SIGNATURE');
1221     my $add_sign_to_dist = $self->cd('$(DISTVNAME)' => $add_sign );
1222
1223     return sprintf <<'MAKE', $add_sign_to_dist, $touch_sig, $sign_dist
1224 distsignature : create_distdir
1225         $(NOECHO) %s
1226         $(NOECHO) %s
1227         %s
1228
1229 MAKE
1230
1231 }
1232
1233
1234 =head3 special_targets
1235
1236   my $make_frag = $mm->special_targets
1237
1238 Returns a make fragment containing any targets which have special
1239 meaning to make.  For example, .SUFFIXES and .PHONY.
1240
1241 =cut
1242
1243 sub special_targets {
1244     my $make_frag = <<'MAKE_FRAG';
1245 .SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
1246
1247 .PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir
1248
1249 MAKE_FRAG
1250
1251     $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT};
1252 .NO_CONFIG_REC: Makefile
1253
1254 MAKE_FRAG
1255
1256     return $make_frag;
1257 }
1258
1259
1260
1261
1262 =head2 Init methods
1263
1264 Methods which help initialize the MakeMaker object and macros.
1265
1266
1267 =head3 init_ABSTRACT
1268
1269     $mm->init_ABSTRACT
1270
1271 =cut
1272
1273 sub init_ABSTRACT {
1274     my $self = shift;
1275
1276     if( $self->{ABSTRACT_FROM} and $self->{ABSTRACT} ) {
1277         warn "Both ABSTRACT_FROM and ABSTRACT are set.  ".
1278              "Ignoring ABSTRACT_FROM.\n";
1279         return;
1280     }
1281
1282     if ($self->{ABSTRACT_FROM}){
1283         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
1284             carp "WARNING: Setting ABSTRACT via file ".
1285                  "'$self->{ABSTRACT_FROM}' failed\n";
1286     }
1287 }
1288
1289 =head3 init_INST
1290
1291     $mm->init_INST;
1292
1293 Called by init_main.  Sets up all INST_* variables except those related
1294 to XS code.  Those are handled in init_xs.
1295
1296 =cut
1297
1298 sub init_INST {
1299     my($self) = shift;
1300
1301     $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
1302     $self->{INST_BIN}     ||= $self->catdir($Curdir,'blib','bin');
1303
1304     # INST_LIB typically pre-set if building an extension after
1305     # perl has been built and installed. Setting INST_LIB allows
1306     # you to build directly into, say $Config{privlibexp}.
1307     unless ($self->{INST_LIB}){
1308         if ($self->{PERL_CORE}) {
1309             if (defined $Cross::platform) {
1310                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = 
1311                   $self->catdir($self->{PERL_LIB},"..","xlib",
1312                                      $Cross::platform);
1313             }
1314             else {
1315                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1316             }
1317         } else {
1318             $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
1319         }
1320     }
1321
1322     my @parentdir = split(/::/, $self->{PARENT_NAME});
1323     $self->{INST_LIBDIR}      = $self->catdir('$(INST_LIB)',     @parentdir);
1324     $self->{INST_ARCHLIBDIR}  = $self->catdir('$(INST_ARCHLIB)', @parentdir);
1325     $self->{INST_AUTODIR}     = $self->catdir('$(INST_LIB)', 'auto', 
1326                                               '$(FULLEXT)');
1327     $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
1328                                               '$(FULLEXT)');
1329
1330     $self->{INST_SCRIPT}  ||= $self->catdir($Curdir,'blib','script');
1331
1332     $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
1333     $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
1334
1335     return 1;
1336 }
1337
1338
1339 =head3 init_INSTALL
1340
1341     $mm->init_INSTALL;
1342
1343 Called by init_main.  Sets up all INSTALL_* variables (except
1344 INSTALLDIRS) and *PREFIX.
1345
1346 =cut
1347
1348 sub init_INSTALL {
1349     my($self) = shift;
1350
1351     if( $self->{ARGS}{INSTALL_BASE} and $self->{ARGS}{PREFIX} ) {
1352         die "Only one of PREFIX or INSTALL_BASE can be given.  Not both.\n";
1353     }
1354
1355     if( $self->{ARGS}{INSTALL_BASE} ) {
1356         $self->init_INSTALL_from_INSTALL_BASE;
1357     }
1358     else {
1359         $self->init_INSTALL_from_PREFIX;
1360     }
1361 }
1362
1363
1364 =head3 init_INSTALL_from_PREFIX
1365
1366   $mm->init_INSTALL_from_PREFIX;
1367
1368 =cut
1369
1370 sub init_INSTALL_from_PREFIX {
1371     my $self = shift;
1372
1373     $self->init_lib2arch;
1374
1375     # There are often no Config.pm defaults for these new man variables so 
1376     # we fall back to the old behavior which is to use installman*dir
1377     foreach my $num (1, 3) {
1378         my $k = 'installsiteman'.$num.'dir';
1379
1380         $self->{uc $k} ||= uc "\$(installman${num}dir)"
1381           unless $Config{$k};
1382     }
1383
1384     foreach my $num (1, 3) {
1385         my $k = 'installvendorman'.$num.'dir';
1386
1387         unless( $Config{$k} ) {
1388             $self->{uc $k}  ||= $Config{usevendorprefix}
1389                               ? uc "\$(installman${num}dir)"
1390                               : '';
1391         }
1392     }
1393
1394     $self->{INSTALLSITEBIN} ||= '$(INSTALLBIN)'
1395       unless $Config{installsitebin};
1396     $self->{INSTALLSITESCRIPT} ||= '$(INSTALLSCRIPT)'
1397       unless $Config{installsitescript};
1398
1399     unless( $Config{installvendorbin} ) {
1400         $self->{INSTALLVENDORBIN} ||= $Config{usevendorprefix} 
1401                                     ? $Config{installbin}
1402                                     : '';
1403     }
1404     unless( $Config{installvendorscript} ) {
1405         $self->{INSTALLVENDORSCRIPT} ||= $Config{usevendorprefix}
1406                                        ? $Config{installscript}
1407                                        : '';
1408     }
1409
1410
1411     my $iprefix = $Config{installprefixexp} || $Config{installprefix} || 
1412                   $Config{prefixexp}        || $Config{prefix} || '';
1413     my $vprefix = $Config{usevendorprefix}  ? $Config{vendorprefixexp} : '';
1414     my $sprefix = $Config{siteprefixexp}    || '';
1415
1416     # 5.005_03 doesn't have a siteprefix.
1417     $sprefix = $iprefix unless $sprefix;
1418
1419
1420     $self->{PREFIX}       ||= '';
1421
1422     if( $self->{PREFIX} ) {
1423         @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
1424           ('$(PREFIX)') x 3;
1425     }
1426     else {
1427         $self->{PERLPREFIX}   ||= $iprefix;
1428         $self->{SITEPREFIX}   ||= $sprefix;
1429         $self->{VENDORPREFIX} ||= $vprefix;
1430
1431         # Lots of MM extension authors like to use $(PREFIX) so we
1432         # put something sensible in there no matter what.
1433         $self->{PREFIX} = '$('.uc $self->{INSTALLDIRS}.'PREFIX)';
1434     }
1435
1436     my $arch    = $Config{archname};
1437     my $version = $Config{version};
1438
1439     # default style
1440     my $libstyle = $Config{installstyle} || 'lib/perl5';
1441     my $manstyle = '';
1442
1443     if( $self->{LIBSTYLE} ) {
1444         $libstyle = $self->{LIBSTYLE};
1445         $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
1446     }
1447
1448     # Some systems, like VOS, set installman*dir to '' if they can't
1449     # read man pages.
1450     for my $num (1, 3) {
1451         $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
1452           unless $Config{'installman'.$num.'dir'};
1453     }
1454
1455     my %bin_layouts = 
1456     (
1457         bin         => { s => $iprefix,
1458                          t => 'perl',
1459                          d => 'bin' },
1460         vendorbin   => { s => $vprefix,
1461                          t => 'vendor',
1462                          d => 'bin' },
1463         sitebin     => { s => $sprefix,
1464                          t => 'site',
1465                          d => 'bin' },
1466         script      => { s => $iprefix,
1467                          t => 'perl',
1468                          d => 'bin' },
1469         vendorscript=> { s => $vprefix,
1470                          t => 'vendor',
1471                          d => 'bin' },
1472         sitescript  => { s => $sprefix,
1473                          t => 'site',
1474                          d => 'bin' },
1475     );
1476     
1477     my %man_layouts =
1478     (
1479         man1dir         => { s => $iprefix,
1480                              t => 'perl',
1481                              d => 'man/man1',
1482                              style => $manstyle, },
1483         siteman1dir     => { s => $sprefix,
1484                              t => 'site',
1485                              d => 'man/man1',
1486                              style => $manstyle, },
1487         vendorman1dir   => { s => $vprefix,
1488                              t => 'vendor',
1489                              d => 'man/man1',
1490                              style => $manstyle, },
1491
1492         man3dir         => { s => $iprefix,
1493                              t => 'perl',
1494                              d => 'man/man3',
1495                              style => $manstyle, },
1496         siteman3dir     => { s => $sprefix,
1497                              t => 'site',
1498                              d => 'man/man3',
1499                              style => $manstyle, },
1500         vendorman3dir   => { s => $vprefix,
1501                              t => 'vendor',
1502                              d => 'man/man3',
1503                              style => $manstyle, },
1504     );
1505
1506     my %lib_layouts =
1507     (
1508         privlib     => { s => $iprefix,
1509                          t => 'perl',
1510                          d => '',
1511                          style => $libstyle, },
1512         vendorlib   => { s => $vprefix,
1513                          t => 'vendor',
1514                          d => '',
1515                          style => $libstyle, },
1516         sitelib     => { s => $sprefix,
1517                          t => 'site',
1518                          d => 'site_perl',
1519                          style => $libstyle, },
1520         
1521         archlib     => { s => $iprefix,
1522                          t => 'perl',
1523                          d => "$version/$arch",
1524                          style => $libstyle },
1525         vendorarch  => { s => $vprefix,
1526                          t => 'vendor',
1527                          d => "$version/$arch",
1528                          style => $libstyle },
1529         sitearch    => { s => $sprefix,
1530                          t => 'site',
1531                          d => "site_perl/$version/$arch",
1532                          style => $libstyle },
1533     );
1534
1535
1536     # Special case for LIB.
1537     if( $self->{LIB} ) {
1538         foreach my $var (keys %lib_layouts) {
1539             my $Installvar = uc "install$var";
1540
1541             if( $var =~ /arch/ ) {
1542                 $self->{$Installvar} ||= 
1543                   $self->catdir($self->{LIB}, $Config{archname});
1544             }
1545             else {
1546                 $self->{$Installvar} ||= $self->{LIB};
1547             }
1548         }
1549     }
1550
1551     my %type2prefix = ( perl    => 'PERLPREFIX',
1552                         site    => 'SITEPREFIX',
1553                         vendor  => 'VENDORPREFIX'
1554                       );
1555
1556     my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
1557     while( my($var, $layout) = each(%layouts) ) {
1558         my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
1559         my $r = '$('.$type2prefix{$t}.')';
1560
1561         print STDERR "Prefixing $var\n" if $Verbose >= 2;
1562
1563         my $installvar = "install$var";
1564         my $Installvar = uc $installvar;
1565         next if $self->{$Installvar};
1566
1567         $d = "$style/$d" if $style;
1568         $self->prefixify($installvar, $s, $r, $d);
1569
1570         print STDERR "  $Installvar == $self->{$Installvar}\n" 
1571           if $Verbose >= 2;
1572     }
1573
1574     # Generate these if they weren't figured out.
1575     $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
1576     $self->{VENDORLIBEXP}  ||= $self->{INSTALLVENDORLIB};
1577
1578     return 1;
1579 }
1580
1581
1582 =head3 init_from_INSTALL_BASE
1583
1584     $mm->init_from_INSTALL_BASE
1585
1586 =cut
1587
1588 my %map = (
1589            lib      => [qw(lib perl5)],
1590            arch     => [('lib', 'perl5', $Config{archname})],
1591            bin      => [qw(bin)],
1592            man1dir  => [qw(man man1)],
1593            man3dir  => [qw(man man3)]
1594           );
1595 $map{script} = $map{bin};
1596
1597 sub init_INSTALL_from_INSTALL_BASE {
1598     my $self = shift;
1599
1600     @{$self}{qw(PREFIX VENDORPREFIX SITEPREFIX PERLPREFIX)} = 
1601                                                          '$(INSTALL_BASE)';
1602
1603     my %install;
1604     foreach my $thing (keys %map) {
1605         foreach my $dir (('', 'SITE', 'VENDOR')) {
1606             my $uc_thing = uc $thing;
1607             my $key = "INSTALL".$dir.$uc_thing;
1608
1609             $install{$key} ||= 
1610               $self->catdir('$(INSTALL_BASE)', @{$map{$thing}});
1611         }
1612     }
1613
1614     # Adjust for variable quirks.
1615     $install{INSTALLARCHLIB} ||= delete $install{INSTALLARCH};
1616     $install{INSTALLPRIVLIB} ||= delete $install{INSTALLLIB};
1617
1618     foreach my $key (keys %install) {
1619         $self->{$key} ||= $install{$key};
1620     }
1621
1622     return 1;
1623 }
1624
1625
1626 =head3 init_VERSION  I<Abstract>
1627
1628     $mm->init_VERSION
1629
1630 Initialize macros representing versions of MakeMaker and other tools
1631
1632 MAKEMAKER: path to the MakeMaker module.
1633
1634 MM_VERSION: ExtUtils::MakeMaker Version
1635
1636 MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards 
1637              compat)
1638
1639 VERSION: version of your module
1640
1641 VERSION_MACRO: which macro represents the version (usually 'VERSION')
1642
1643 VERSION_SYM: like version but safe for use as an RCS revision number
1644
1645 DEFINE_VERSION: -D line to set the module version when compiling
1646
1647 XS_VERSION: version in your .xs file.  Defaults to $(VERSION)
1648
1649 XS_VERSION_MACRO: which macro represents the XS version.
1650
1651 XS_DEFINE_VERSION: -D line to set the xs version when compiling.
1652
1653 Called by init_main.
1654
1655 =cut
1656
1657 sub init_VERSION {
1658     my($self) = shift;
1659
1660     $self->{MAKEMAKER}  = $ExtUtils::MakeMaker::Filename;
1661     $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION;
1662     $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision;
1663     $self->{VERSION_FROM} ||= '';
1664
1665     if ($self->{VERSION_FROM}){
1666         $self->{VERSION} = $self->parse_version($self->{VERSION_FROM});
1667         if( $self->{VERSION} eq 'undef' ) {
1668             carp("WARNING: Setting VERSION via file ".
1669                  "'$self->{VERSION_FROM}' failed\n");
1670         }
1671     }
1672
1673     # strip blanks
1674     if (defined $self->{VERSION}) {
1675         $self->{VERSION} =~ s/^\s+//;
1676         $self->{VERSION} =~ s/\s+$//;
1677     }
1678     else {
1679         $self->{VERSION} = '';
1680     }
1681
1682
1683     $self->{VERSION_MACRO}  = 'VERSION';
1684     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1685     $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"';
1686
1687
1688     # Graham Barr and Paul Marquess had some ideas how to ensure
1689     # version compatibility between the *.pm file and the
1690     # corresponding *.xs file. The bottomline was, that we need an
1691     # XS_VERSION macro that defaults to VERSION:
1692     $self->{XS_VERSION} ||= $self->{VERSION};
1693
1694     $self->{XS_VERSION_MACRO}  = 'XS_VERSION';
1695     $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"';
1696
1697 }
1698
1699
1700 =head3 init_others
1701
1702     $MM->init_others();
1703
1704 Initializes the macro definitions used by tools_other() and places them
1705 in the $MM object.
1706
1707 If there is no description, its the same as the parameter to
1708 WriteMakefile() documented in ExtUtils::MakeMaker.
1709
1710 Defines at least these macros.
1711
1712   Macro             Description
1713
1714   NOOP              Do nothing
1715   NOECHO            Tell make not to display the command itself
1716
1717   MAKEFILE
1718   FIRST_MAKEFILE
1719   MAKEFILE_OLD
1720   MAKE_APERL_FILE   File used by MAKE_APERL
1721
1722   SHELL             Program used to run shell commands
1723
1724   ECHO              Print text adding a newline on the end
1725   RM_F              Remove a file 
1726   RM_RF             Remove a directory          
1727   TOUCH             Update a file's timestamp   
1728   TEST_F            Test for a file's existence 
1729   CP                Copy a file                 
1730   MV                Move a file                 
1731   CHMOD             Change permissions on a file
1732   FALSE             Exit with non-zero
1733   TRUE              Exit with zero
1734
1735   UMASK_NULL        Nullify umask
1736   DEV_NULL          Suppress all command output
1737
1738 =cut
1739
1740 sub init_others {
1741     my $self = shift;
1742
1743     $self->{ECHO}     ||= $self->oneliner('print qq{@ARGV}', ['-l']);
1744     $self->{ECHO_N}   ||= $self->oneliner('print qq{@ARGV}');
1745
1746     $self->{TOUCH}    ||= $self->oneliner('touch', ["-MExtUtils::Command"]);
1747     $self->{CHMOD}    ||= $self->oneliner('chmod', ["-MExtUtils::Command"]);
1748     $self->{RM_F}     ||= $self->oneliner('rm_f',  ["-MExtUtils::Command"]);
1749     $self->{RM_RF}    ||= $self->oneliner('rm_rf', ["-MExtUtils::Command"]);
1750     $self->{TEST_F}   ||= $self->oneliner('test_f', ["-MExtUtils::Command"]);
1751     $self->{FALSE}    ||= $self->oneliner('exit 1');
1752     $self->{TRUE}     ||= $self->oneliner('exit 0');
1753
1754     $self->{MKPATH}   ||= $self->oneliner('mkpath', ["-MExtUtils::Command"]);
1755
1756     $self->{CP}       ||= $self->oneliner('cp', ["-MExtUtils::Command"]);
1757     $self->{MV}       ||= $self->oneliner('mv', ["-MExtUtils::Command"]);
1758
1759     $self->{MOD_INSTALL} ||= 
1760       $self->oneliner(<<'CODE', ['-MExtUtils::Install']);
1761 install([ from_to => {@ARGV}, verbose => '$(VERBINST)', uninstall_shadows => '$(UNINST)', dir_mode => '$(PERM_DIR)' ]);
1762 CODE
1763     $self->{DOC_INSTALL} ||= $self->oneliner('perllocal_install', ["-MExtUtils::Command::MM"]);
1764     $self->{UNINSTALL}   ||= $self->oneliner('uninstall', ["-MExtUtils::Command::MM"]);
1765     $self->{WARN_IF_OLD_PACKLIST} ||= 
1766       $self->oneliner('warn_if_old_packlist', ["-MExtUtils::Command::MM"]);
1767     $self->{FIXIN}       ||= $self->oneliner('MY->fixin(shift)', ["-MExtUtils::MY"]);
1768     $self->{EQUALIZE_TIMESTAMP} ||= $self->oneliner('eqtime', ["-MExtUtils::Command"]);
1769
1770     $self->{UNINST}     ||= 0;
1771     $self->{VERBINST}   ||= 0;
1772
1773     $self->{FIRST_MAKEFILE}     ||= $self->{MAKEFILE} || 'Makefile';
1774     $self->{MAKEFILE}           ||= $self->{FIRST_MAKEFILE};
1775     $self->{MAKEFILE_OLD}       ||= $self->{MAKEFILE}.'.old';
1776     $self->{MAKE_APERL_FILE}    ||= $self->{MAKEFILE}.'.aperl';
1777
1778     # Not everybody uses -f to indicate "use this Makefile instead"
1779     $self->{USEMAKEFILE}        ||= '-f';
1780
1781     # Some makes require a wrapper around macros passed in on the command 
1782     # line.
1783     $self->{MACROSTART}         ||= '';
1784     $self->{MACROEND}           ||= '';
1785
1786     $self->{SHELL}              ||= $Config{sh};
1787
1788     # UMASK_NULL is not used by MakeMaker but some CPAN modules
1789     # make use of it.
1790     $self->{UMASK_NULL}         ||= "umask 0";
1791
1792     # Not the greatest default, but its something.
1793     $self->{DEV_NULL}           ||= "> /dev/null 2>&1";
1794
1795     $self->{NOOP}               ||= '$(TRUE)';
1796     $self->{NOECHO}             = '@' unless defined $self->{NOECHO};
1797
1798     $self->{LD_RUN_PATH} = "";
1799
1800     $self->{LIBS} = $self->_fix_libs($self->{LIBS});
1801
1802     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1803     foreach my $libs ( @{$self->{LIBS}} ){
1804         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1805         my(@libs) = $self->extliblist($libs);
1806         if ($libs[0] or $libs[1] or $libs[2]){
1807             # LD_RUN_PATH now computed by ExtUtils::Liblist
1808             ($self->{EXTRALIBS},  $self->{BSLOADLIBS}, 
1809              $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1810             last;
1811         }
1812     }
1813
1814     if ( $self->{OBJECT} ) {
1815         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1816     } else {
1817         # init_dirscan should have found out, if we have C files
1818         $self->{OBJECT} = "";
1819         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1820     }
1821     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1822
1823     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1824     $self->{PERLMAINCC} ||= '$(CC)';
1825     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1826
1827     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1828     # the 'dynamic' section of MM.  We don't have this problem with
1829     # 'static', since we either must use it (%Config says we can't
1830     # use dynamic loading) or the caller asked for it explicitly.
1831     if (!$self->{LINKTYPE}) {
1832        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1833                         ? 'static'
1834                         : ($Config{usedl} ? 'dynamic' : 'static');
1835     }
1836
1837     return 1;
1838 }
1839
1840
1841 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1842 # undefined. In any case we turn it into an anon array
1843 sub _fix_libs {
1844     my($self, $libs) = @_;
1845
1846     return !defined $libs       ? ['']          : 
1847            !ref $libs           ? [$libs]       :
1848            !defined $libs->[0]  ? ['']          :
1849                                   $libs         ;
1850 }
1851
1852
1853 =head3 tools_other
1854
1855     my $make_frag = $MM->tools_other;
1856
1857 Returns a make fragment containing definitions for the macros init_others() 
1858 initializes.
1859
1860 =cut
1861
1862 sub tools_other {
1863     my($self) = shift;
1864     my @m;
1865
1866     # We set PM_FILTER as late as possible so it can see all the earlier
1867     # on macro-order sensitive makes such as nmake.
1868     for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH 
1869                       UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP
1870                       FALSE TRUE
1871                       ECHO ECHO_N
1872                       UNINST VERBINST
1873                       MOD_INSTALL DOC_INSTALL UNINSTALL
1874                       WARN_IF_OLD_PACKLIST
1875                       MACROSTART MACROEND
1876                       USEMAKEFILE
1877                       PM_FILTER
1878                       FIXIN
1879                     } ) 
1880     {
1881         next unless defined $self->{$tool};
1882         push @m, "$tool = $self->{$tool}\n";
1883     }
1884
1885     return join "", @m;
1886 }
1887
1888
1889 =head3 init_DIRFILESEP  I<Abstract>
1890
1891   $MM->init_DIRFILESEP;
1892   my $dirfilesep = $MM->{DIRFILESEP};
1893
1894 Initializes the DIRFILESEP macro which is the seperator between the
1895 directory and filename in a filepath.  ie. / on Unix, \ on Win32 and
1896 nothing on VMS.
1897
1898 For example:
1899
1900     # instead of $(INST_ARCHAUTODIR)/extralibs.ld
1901     $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld
1902
1903 Something of a hack but it prevents a lot of code duplication between
1904 MM_* variants.
1905
1906 Do not use this as a seperator between directories.  Some operating
1907 systems use different seperators between subdirectories as between
1908 directories and filenames (for example:  VOLUME:[dir1.dir2]file on VMS).
1909
1910 =head3 init_linker  I<Abstract>
1911
1912     $mm->init_linker;
1913
1914 Initialize macros which have to do with linking.
1915
1916 PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic
1917 extensions.
1918
1919 PERL_ARCHIVE_AFTER: path to a library which should be put on the
1920 linker command line I<after> the external libraries to be linked to
1921 dynamic extensions.  This may be needed if the linker is one-pass, and
1922 Perl includes some overrides for C RTL functions, such as malloc().
1923
1924 EXPORT_LIST: name of a file that is passed to linker to define symbols
1925 to be exported.
1926
1927 Some OSes do not need these in which case leave it blank.
1928
1929
1930 =head3 init_platform
1931
1932     $mm->init_platform
1933
1934 Initialize any macros which are for platform specific use only.
1935
1936 A typical one is the version number of your OS specific mocule.
1937 (ie. MM_Unix_VERSION or MM_VMS_VERSION).
1938
1939 =cut
1940
1941 sub init_platform {
1942     return '';
1943 }
1944
1945
1946 =head3 init_MAKE
1947
1948     $mm->init_MAKE
1949
1950 Initialize MAKE from either a MAKE environment variable or $Config{make}.
1951
1952 =cut
1953
1954 sub init_MAKE {
1955     my $self = shift;
1956
1957     $self->{MAKE} ||= $ENV{MAKE} || $Config{make};
1958 }
1959
1960
1961 =head2 Tools
1962
1963 A grab bag of methods to generate specific macros and commands.
1964
1965
1966
1967 =head3 manifypods
1968
1969 Defines targets and routines to translate the pods into manpages and
1970 put them into the INST_* directories.
1971
1972 =cut
1973
1974 sub manifypods {
1975     my $self          = shift;
1976
1977     my $POD2MAN_macro = $self->POD2MAN_macro();
1978     my $manifypods_target = $self->manifypods_target();
1979
1980     return <<END_OF_TARGET;
1981
1982 $POD2MAN_macro
1983
1984 $manifypods_target
1985
1986 END_OF_TARGET
1987
1988 }
1989
1990
1991 =head3 POD2MAN_macro
1992
1993   my $pod2man_macro = $self->POD2MAN_macro
1994
1995 Returns a definition for the POD2MAN macro.  This is a program
1996 which emulates the pod2man utility.  You can add more switches to the
1997 command by simply appending them on the macro.
1998
1999 Typical usage:
2000
2001     $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) podfile1 man_page1 ...
2002
2003 =cut
2004
2005 sub POD2MAN_macro {
2006     my $self = shift;
2007
2008 # Need the trailing '--' so perl stops gobbling arguments and - happens
2009 # to be an alternative end of line seperator on VMS so we quote it
2010     return <<'END_OF_DEF';
2011 POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
2012 POD2MAN = $(POD2MAN_EXE)
2013 END_OF_DEF
2014 }
2015
2016
2017 =head3 test_via_harness
2018
2019   my $command = $mm->test_via_harness($perl, $tests);
2020
2021 Returns a $command line which runs the given set of $tests with
2022 Test::Harness and the given $perl.
2023
2024 Used on the t/*.t files.
2025
2026 =cut
2027
2028 sub test_via_harness {
2029     my($self, $perl, $tests) = @_;
2030
2031     return qq{\t$perl "-MExtUtils::Command::MM" }.
2032            qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n};
2033 }
2034
2035 =head3 test_via_script
2036
2037   my $command = $mm->test_via_script($perl, $script);
2038
2039 Returns a $command line which just runs a single test without
2040 Test::Harness.  No checks are done on the results, they're just
2041 printed.
2042
2043 Used for test.pl, since they don't always follow Test::Harness
2044 formatting.
2045
2046 =cut
2047
2048 sub test_via_script {
2049     my($self, $perl, $script) = @_;
2050     return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n};
2051 }
2052
2053
2054 =head3 tool_autosplit
2055
2056 Defines a simple perl call that runs autosplit. May be deprecated by
2057 pm_to_blib soon.
2058
2059 =cut
2060
2061 sub tool_autosplit {
2062     my($self, %attribs) = @_;
2063
2064     my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' 
2065                                   : '';
2066
2067     my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen);
2068 use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)
2069 PERL_CODE
2070
2071     return sprintf <<'MAKE_FRAG', $asplit;
2072 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
2073 AUTOSPLITFILE = %s
2074
2075 MAKE_FRAG
2076
2077 }
2078
2079
2080 =head3 arch_check
2081
2082     my $arch_ok = $mm->arch_check(
2083         $INC{"Config.pm"},
2084         File::Spec->catfile($Config{archlibexp}, "Config.pm")
2085     );
2086
2087 A sanity check that what Perl thinks the architecture is and what
2088 Config thinks the architecture is are the same.  If they're not it
2089 will return false and show a diagnostic message.
2090
2091 When building Perl it will always return true, as nothing is installed
2092 yet.
2093
2094 The interface is a bit odd because this is the result of a
2095 quick refactoring.  Don't rely on it.
2096
2097 =cut
2098
2099 sub arch_check {
2100     my $self = shift;
2101     my($pconfig, $cconfig) = @_;
2102
2103     return 1 if $self->{PERL_SRC};
2104
2105     my($pvol, $pthinks) = $self->splitpath($pconfig);
2106     my($cvol, $cthinks) = $self->splitpath($cconfig);
2107
2108     $pthinks = $self->canonpath($pthinks);
2109     $cthinks = $self->canonpath($cthinks);
2110
2111     my $ret = 1;
2112     if ($pthinks ne $cthinks) {
2113         print "Have $pthinks\n";
2114         print "Want $cthinks\n";
2115
2116         $ret = 0;
2117
2118         my $arch = (grep length, $self->splitdir($pthinks))[-1];
2119
2120         print STDOUT <<END unless $self->{UNINSTALLED_PERL};
2121 Your perl and your Config.pm seem to have different ideas about the 
2122 architecture they are running on.
2123 Perl thinks: [$arch]
2124 Config says: [$Config{archname}]
2125 This may or may not cause problems. Please check your installation of perl 
2126 if you have problems building this extension.
2127 END
2128     }
2129
2130     return $ret;
2131 }
2132
2133
2134
2135 =head2 File::Spec wrappers
2136
2137 ExtUtils::MM_Any is a subclass of File::Spec.  The methods noted here
2138 override File::Spec.
2139
2140
2141
2142 =head3 catfile
2143
2144 File::Spec <= 0.83 has a bug where the file part of catfile is not
2145 canonicalized.  This override fixes that bug.
2146
2147 =cut
2148
2149 sub catfile {
2150     my $self = shift;
2151     return $self->canonpath($self->SUPER::catfile(@_));
2152 }
2153
2154
2155
2156 =head2 Misc
2157
2158 Methods I can't really figure out where they should go yet.
2159
2160
2161 =head3 find_tests
2162
2163   my $test = $mm->find_tests;
2164
2165 Returns a string suitable for feeding to the shell to return all
2166 tests in t/*.t.
2167
2168 =cut
2169
2170 sub find_tests {
2171     my($self) = shift;
2172     return -d 't' ? 't/*.t' : '';
2173 }
2174
2175
2176 =head3 extra_clean_files
2177
2178     my @files_to_clean = $MM->extra_clean_files;
2179
2180 Returns a list of OS specific files to be removed in the clean target in
2181 addition to the usual set.
2182
2183 =cut
2184
2185 # An empty method here tickled a perl 5.8.1 bug and would return its object.
2186 sub extra_clean_files { 
2187     return;
2188 }
2189
2190
2191 =head3 installvars
2192
2193     my @installvars = $mm->installvars;
2194
2195 A list of all the INSTALL* variables without the INSTALL prefix.  Useful
2196 for iteration or building related variable sets.
2197
2198 =cut
2199
2200 sub installvars {
2201     return qw(PRIVLIB SITELIB  VENDORLIB
2202               ARCHLIB SITEARCH VENDORARCH
2203               BIN     SITEBIN  VENDORBIN
2204               SCRIPT  SITESCRIPT  VENDORSCRIPT
2205               MAN1DIR SITEMAN1DIR VENDORMAN1DIR
2206               MAN3DIR SITEMAN3DIR VENDORMAN3DIR
2207              );
2208 }
2209
2210
2211 =head3 libscan
2212
2213   my $wanted = $self->libscan($path);
2214
2215 Takes a path to a file or dir and returns an empty string if we don't
2216 want to include this file in the library.  Otherwise it returns the
2217 the $path unchanged.
2218
2219 Mainly used to exclude version control administrative directories from
2220 installation.
2221
2222 =cut
2223
2224 sub libscan {
2225     my($self,$path) = @_;
2226     my($dirs,$file) = ($self->splitpath($path))[1,2];
2227     return '' if grep /^(?:RCS|CVS|SCCS|\.svn|_darcs)$/, 
2228                      $self->splitdir($dirs), $file;
2229
2230     return $path;
2231 }
2232
2233
2234 =head3 platform_constants
2235
2236     my $make_frag = $mm->platform_constants
2237
2238 Returns a make fragment defining all the macros initialized in
2239 init_platform() rather than put them in constants().
2240
2241 =cut
2242
2243 sub platform_constants {
2244     return '';
2245 }
2246
2247 =begin private
2248
2249 =head3 _PREREQ_PRINT
2250
2251     $self->_PREREQ_PRINT;
2252
2253 Implements PREREQ_PRINT.
2254
2255 Refactored out of MakeMaker->new().
2256
2257 =end private
2258
2259 =cut
2260
2261 sub _PREREQ_PRINT {
2262     my $self = shift;
2263
2264     require Data::Dumper;
2265     my @what = ('PREREQ_PM');
2266     push @what, 'MIN_PERL_VERSION' if $self->{MIN_PERL_VERSION};
2267     push @what, 'BUILD_REQUIRES'   if $self->{BUILD_REQUIRES};
2268     print Data::Dumper->Dump([@{$self}{@what}], \@what);
2269     exit 0;
2270 }
2271
2272
2273 =begin private
2274
2275 =head3 _PRINT_PREREQ
2276
2277   $mm->_PRINT_PREREQ;
2278
2279 Implements PRINT_PREREQ, a slightly different version of PREREQ_PRINT
2280 added by Redhat to, I think, support generating RPMs from Perl modules.
2281
2282 Refactored out of MakeMaker->new().
2283
2284 =end private
2285
2286 =cut
2287
2288 sub _PRINT_PREREQ {
2289     my $self = shift;
2290
2291     my $prereqs= $self->_all_prereqs;
2292     my @prereq = map { [$_, $prereqs->{$_}] } keys %$prereqs;
2293
2294     if ( $self->{MIN_PERL_VERSION} ) {
2295         push @prereq, ['perl' => $self->{MIN_PERL_VERSION}];
2296     }
2297
2298     print join(" ", map { "perl($_->[0])>=$_->[1] " }
2299                  sort { $a->[0] cmp $b->[0] } @prereq), "\n";
2300     exit 0;
2301 }
2302
2303
2304 =begin private
2305
2306 =head3 _all_prereqs
2307
2308   my $prereqs = $self->_all_prereqs;
2309
2310 Returns a hash ref of both PREREQ_PM and BUILD_REQUIRES.
2311
2312 =end private
2313
2314 =cut
2315
2316 sub _all_prereqs {
2317     my $self = shift;
2318
2319     return { %{$self->{PREREQ_PM}}, %{$self->{BUILD_REQUIRES}} };
2320 }
2321
2322
2323 =head1 AUTHOR
2324
2325 Michael G Schwern <schwern@pobox.com> and the denizens of
2326 makemaker@perl.org with code from ExtUtils::MM_Unix and
2327 ExtUtils::MM_Win32.
2328
2329
2330 =cut
2331
2332 1;