This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to ExtUtils-MakeMaker-6.48
[perl5.git] / lib / ExtUtils / MM_Any.pm
index c0ffb2f..5e4bd69 100644 (file)
@@ -1,17 +1,28 @@
 package ExtUtils::MM_Any;
 
 use strict;
-use vars qw($VERSION @ISA);
-$VERSION = 0.05;
-@ISA = qw(File::Spec);
+our $VERSION = '6.48';
 
-use Config;
+use Carp;
 use File::Spec;
+BEGIN { our @ISA = qw(File::Spec); }
+
+# We need $Verbose
+use ExtUtils::MakeMaker qw($Verbose);
+
+use ExtUtils::MakeMaker::Config;
+
+
+# So we don't have to keep calling the methods over and over again,
+# we have these globals to cache the values.  Faster and shrtr.
+my $Curdir  = __PACKAGE__->curdir;
+my $Rootdir = __PACKAGE__->rootdir;
+my $Updir   = __PACKAGE__->updir;
 
 
 =head1 NAME
 
-ExtUtils::MM_Any - Platform agnostic MM methods
+ExtUtils::MM_Any - Platform-agnostic MM methods
 
 =head1 SYNOPSIS
 
@@ -37,17 +48,45 @@ temporary solution.
 
 B<THIS MAY BE TEMPORARY!>
 
-=head1 Inherently Cross-Platform Methods
 
-These are methods which are by their nature cross-platform and should
-always be cross-platform.
+=head1 METHODS
+
+Any methods marked I<Abstract> must be implemented by subclasses.
+
+
+=head2 Cross-platform helper methods
+
+These are methods which help writing cross-platform code.
+
+
+
+=head3 os_flavor  I<Abstract>
+
+    my @os_flavor = $mm->os_flavor;
+
+@os_flavor is the style of operating system this is, usually
+corresponding to the MM_*.pm file we're using.  
+
+The first element of @os_flavor is the major family (ie. Unix,
+Windows, VMS, OS/2, etc...) and the rest are sub families.
+
+Some examples:
+
+    Cygwin98       ('Unix',  'Cygwin', 'Cygwin9x')
+    Windows NT     ('Win32', 'WinNT')
+    Win98          ('Win32', 'Win9x')
+    Linux          ('Unix',  'Linux')
+    MacOS X        ('Unix',  'Darwin', 'MacOS', 'MacOS X')
+    OS/2           ('OS/2')
+
+This is used to write code for styles of operating system.  
+See os_flavor_is() for use.
 
-=over 4
 
-=item os_flavor_is
+=head3 os_flavor_is
 
-    $mm->os_flavor_is($this_flavor);
-    $mm->os_flavor_is(@one_of_these_flavors);
+    my $is_this_flavor = $mm->os_flavor_is($this_flavor);
+    my $is_this_flavor = $mm->os_flavor_is(@one_of_these_flavors);
 
 Checks to see if the current operating system is one of the given flavors.
 
@@ -68,38 +107,8 @@ sub os_flavor_is {
     return (grep { $flavors{$_} } @_) ? 1 : 0;
 }
 
-=back
-
-=head2 File::Spec wrappers
-
-ExtUtils::MM_Any is a subclass of File::Spec.  The methods noted here
-override File::Spec.
-
-=over 4
-
-=item catfile
-
-File::Spec <= 0.83 has a bug where the file part of catfile is not
-canonicalized.  This override fixes that bug.
-
-=cut
-
-sub catfile {
-    my $self = shift;
-    return $self->canonpath($self->SUPER::catfile(@_));
-}
-
-=back
 
-=head1 Thought To Be Cross-Platform Methods
-
-These are methods which are thought to be cross-platform by virtue of
-having been written in a way to avoid incompatibilities.  They may
-require partial overrides.
-
-=over 4
-
-=item B<split_command>
+=head3 split_command
 
     my @cmds = $MM->split_command($cmd, @args);
 
@@ -107,7 +116,7 @@ Most OS have a maximum command length they can execute at once.  Large
 modules can easily generate commands well past that limit.  Its
 necessary to split long commands up into a series of shorter commands.
 
-split_command() will return a series of @cmds each processing part of
+C<split_command> will return a series of @cmds each processing part of
 the args.  Collectively they will process all the arguments.  Each
 individual line in @cmds will not be longer than the
 $self->max_exec_len being careful to take into account macro expansion.
@@ -135,8 +144,8 @@ sub split_command {
     # newline.
     chomp $cmd;
 
-    # set aside 20% for macro expansion.
-    my $len_left = int($self->max_exec_len * 0.80);
+    # set aside 30% for macro expansion.
+    my $len_left = int($self->max_exec_len * 0.70);
     $len_left -= length $self->_expand_macros($cmd);
 
     do {
@@ -159,7 +168,7 @@ sub split_command {
         }
         chop $arg_str;
 
-        push @cmds, $self->escape_newlines("$cmd\n$arg_str");
+        push @cmds, $self->escape_newlines("$cmd \n$arg_str");
     } while @args;
 
     return @cmds;
@@ -176,7 +185,7 @@ sub _expand_macros {
 }
 
 
-=item B<echo>
+=head3 echo
 
     my @commands = $MM->echo($text);
     my @commands = $MM->echo($text, $file);
@@ -207,609 +216,1794 @@ sub echo {
 }
 
 
-=item init_VERSION
+=head3 wraplist
 
-    $mm->init_VERSION
+  my $args = $mm->wraplist(@list);
 
-Initialize macros representing versions of MakeMaker and other tools
+Takes an array of items and turns them into a well-formatted list of
+arguments.  In most cases this is simply something like:
 
-MAKEMAKER: path to the MakeMaker module.
+    FOO \
+    BAR \
+    BAZ
 
-MM_VERSION: ExtUtils::MakeMaker Version
+=cut
 
-MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards 
-             compat)
+sub wraplist {
+    my $self = shift;
+    return join " \\\n\t", @_;
+}
 
-VERSION: version of your module
 
-VERSION_MACRO: which macro represents the version (usually 'VERSION')
+=head3 maketext_filter
 
-VERSION_SYM: like version but safe for use as an RCS revision number
+    my $filter_make_text = $mm->maketext_filter($make_text);
 
-DEFINE_VERSION: -D line to set the module version when compiling
+The text of the Makefile is run through this method before writing to
+disk.  It allows systems a chance to make portability fixes to the
+Makefile.
 
-XS_VERSION: version in your .xs file.  Defaults to $(VERSION)
+By default it does nothing.
 
-XS_VERSION_MACRO: which macro represents the XS version.
+This method is protected and not intended to be called outside of
+MakeMaker.
 
-XS_DEFINE_VERSION: -D line to set the xs version when compiling.
+=cut
 
-Called by init_main.
+sub maketext_filter { return $_[1] }
 
-=cut
 
-sub init_VERSION {
-    my($self) = shift;
+=head3 cd  I<Abstract>
 
-    $self->{MAKEMAKER}  = $ExtUtils::MakeMaker::Filename;
-    $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION;
-    $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision;
-    $self->{VERSION_FROM} ||= '';
+  my $subdir_cmd = $MM->cd($subdir, @cmds);
 
-    if ($self->{VERSION_FROM}){
-        $self->{VERSION} = $self->parse_version($self->{VERSION_FROM});
-        if( $self->{VERSION} eq 'undef' ) {
-            require Carp;
-            Carp::carp("WARNING: Setting VERSION via file ".
-                       "'$self->{VERSION_FROM}' failed\n");
-        }
-    }
+This will generate a make fragment which runs the @cmds in the given
+$dir.  The rough equivalent to this, except cross platform.
 
-    # strip blanks
-    if (defined $self->{VERSION}) {
-        $self->{VERSION} =~ s/^\s+//;
-        $self->{VERSION} =~ s/\s+$//;
-    }
-    else {
-        $self->{VERSION} = '';
-    }
+  cd $subdir && $cmd
 
+Currently $dir can only go down one level.  "foo" is fine.  "foo/bar" is
+not.  "../foo" is right out.
 
-    $self->{VERSION_MACRO}  = 'VERSION';
-    ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
-    $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"';
+The resulting $subdir_cmd has no leading tab nor trailing newline.  This
+makes it easier to embed in a make string.  For example.
 
+      my $make = sprintf <<'CODE', $subdir_cmd;
+  foo :
+      $(ECHO) what
+      %s
+      $(ECHO) mouche
+  CODE
 
-    # Graham Barr and Paul Marquess had some ideas how to ensure
-    # version compatibility between the *.pm file and the
-    # corresponding *.xs file. The bottomline was, that we need an
-    # XS_VERSION macro that defaults to VERSION:
-    $self->{XS_VERSION} ||= $self->{VERSION};
 
-    $self->{XS_VERSION_MACRO}  = 'XS_VERSION';
-    $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"';
+=head3 oneliner  I<Abstract>
 
-}
+  my $oneliner = $MM->oneliner($perl_code);
+  my $oneliner = $MM->oneliner($perl_code, \@switches);
 
-=item wraplist
+This will generate a perl one-liner safe for the particular platform
+you're on based on the given $perl_code and @switches (a -e is
+assumed) suitable for using in a make target.  It will use the proper
+shell quoting and escapes.
 
-Takes an array of items and turns them into a well-formatted list of
-arguments.  In most cases this is simply something like:
+$(PERLRUN) will be used as perl.
 
-    FOO \
-    BAR \
-    BAZ
+Any newlines in $perl_code will be escaped.  Leading and trailing
+newlines will be stripped.  Makes this idiom much easier:
 
-=cut
+    my $code = $MM->oneliner(<<'CODE', [...switches...]);
+some code here
+another line here
+CODE
 
-sub wraplist {
-    my $self = shift;
-    return join " \\\n\t", @_;
-}
+Usage might be something like:
 
-=item manifypods
+    # an echo emulation
+    $oneliner = $MM->oneliner('print "Foo\n"');
+    $make = '$oneliner > somefile';
 
-Defines targets and routines to translate the pods into manpages and
-put them into the INST_* directories.
+All dollar signs must be doubled in the $perl_code if you expect them
+to be interpreted normally, otherwise it will be considered a make
+macro.  Also remember to quote make macros else it might be used as a
+bareword.  For example:
 
-=cut
+    # Assign the value of the $(VERSION_FROM) make macro to $vf.
+    $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"');
 
-sub manifypods {
-    my $self          = shift;
+Its currently very simple and may be expanded sometime in the figure
+to include more flexible code and switches.
 
-    my $POD2MAN_EXE_macro = $self->POD2MAN_EXE_macro();
-    my $manifypods_target = $self->manifypods_target();
 
-    return <<END_OF_TARGET;
+=head3 quote_literal  I<Abstract>
 
-# --- Begin manifypods section:
-$POD2MAN_EXE_macro
+    my $safe_text = $MM->quote_literal($text);
 
-$manifypods_target
+This will quote $text so it is interpreted literally in the shell.
 
-# --- End manifypods section --- #
+For example, on Unix this would escape any single-quotes in $text and
+put single-quotes around the whole thing.
 
-END_OF_TARGET
 
-}
+=head3 escape_newlines  I<Abstract>
 
+    my $escaped_text = $MM->escape_newlines($text);
 
-=item manifypods_target
+Shell escapes newlines in $text.
 
-  my $manifypods_target = $self->manifypods_target;
 
-Generates the manifypods target.  This target generates man pages from
-all POD files in MAN1PODS and MAN3PODS.
+=head3 max_exec_len  I<Abstract>
 
-=cut
+    my $max_exec_len = $MM->max_exec_len;
 
-sub manifypods_target {
-    my($self) = shift;
+Calculates the maximum command size the OS can exec.  Effectively,
+this is the max size of a shell command line.
 
-    my $man1pods      = '';
-    my $man3pods      = '';
-    my $dependencies  = '';
+=for _private
+$self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes.
 
-    # populate manXpods & dependencies:
-    foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) {
-        $dependencies .= " \\\n\t$name";
-    }
 
-    foreach my $name (keys %{$self->{MAN3PODS}}) {
-        $dependencies .= " \\\n\t$name"
-    }
+=head3 make
 
-    my $manify = <<END;
-manifypods : pure_all $dependencies
-END
+    my $make = $MM->make;
 
-    my @man_cmds;
-    foreach my $section (qw(1 3)) {
-        my $pods = $self->{"MAN${section}PODS"};
-        push @man_cmds, $self->split_command(<<CMD, %$pods);
-       \$(NOECHO) \$(POD2MAN_EXE) --section=$section --perm_rw=\$(PERM_RW)
-CMD
-    }
+Returns the make variant we're generating the Makefile for.  This attempts
+to do some normalization on the information from %Config or the user.
 
-    $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
-    $manify .= join '', map { "$_\n" } @man_cmds;
+=cut
 
-    return $manify;
+sub make {
+    my $self = shift;
+
+    my $make = lc $self->{MAKE};
+
+    # Truncate anything like foomake6 to just foomake.
+    $make =~ s/^(\w+make).*/$1/;
+
+    # Turn gnumake into gmake.
+    $make =~ s/^gnu/g/;
+
+    return $make;
 }
 
 
-=item makemakerdflt_target
+=head2 Targets
 
-  my $make_frag = $mm->makemakerdflt_target
+These are methods which produce make targets.
 
-Returns a make fragment with the makemakerdeflt_target specified.
-This target is the first target in the Makefile, is the default target
-and simply points off to 'all' just in case any make variant gets
-confused or something gets snuck in before the real 'all' target.
+
+=head3 all_target
+
+Generate the default target 'all'.
 
 =cut
 
-sub makemakerdflt_target {
-    return <<'MAKE_FRAG';
-makemakerdflt: all
+sub all_target {
+    my $self = shift;
+
+    return <<'MAKE_EXT';
+all :: pure_all
        $(NOECHO) $(NOOP)
-MAKE_FRAG
+MAKE_EXT
 
 }
 
 
-=item special_targets
+=head3 blibdirs_target
 
-  my $make_frag = $mm->special_targets
+    my $make_frag = $mm->blibdirs_target;
+
+Creates the blibdirs target which creates all the directories we use
+in blib/.
+
+The blibdirs.ts target is deprecated.  Depend on blibdirs instead.
 
-Returns a make fragment containing any targets which have special
-meaning to make.  For example, .SUFFIXES and .PHONY.
 
 =cut
 
-sub special_targets {
-    my $make_frag = <<'MAKE_FRAG';
-.SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
+sub blibdirs_target {
+    my $self = shift;
 
-.PHONY: all config static dynamic test linkext manifest
+    my @dirs = map { uc "\$(INST_$_)" } qw(libdir archlib
+                                           autodir archautodir
+                                           bin script
+                                           man1dir man3dir
+                                          );
 
-MAKE_FRAG
+    my @exists = map { $_.'$(DFSEP).exists' } @dirs;
 
-    $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT};
-.NO_CONFIG_REC: Makefile
+    my $make = sprintf <<'MAKE', join(' ', @exists);
+blibdirs : %s
+       $(NOECHO) $(NOOP)
 
-MAKE_FRAG
+# Backwards compat with 6.18 through 6.25
+blibdirs.ts : blibdirs
+       $(NOECHO) $(NOOP)
 
-    return $make_frag;
-}
+MAKE
 
-=item POD2MAN_EXE_macro
+    $make .= $self->dir_target(@dirs);
 
-  my $pod2man_exe_macro = $self->POD2MAN_EXE_macro
+    return $make;
+}
 
-Returns a definition for the POD2MAN_EXE macro.  This is a program
-which emulates the pod2man utility.  You can add more switches to the
-command by simply appending them on the macro.
 
-Typical usage:
+=head3 clean (o)
 
-    $(POD2MAN_EXE) --section=3 --perm_rw=$(PERM_RW) podfile man_page
+Defines the clean target.
 
 =cut
 
-sub POD2MAN_EXE_macro {
-    my $self = shift;
+sub clean {
+# --- Cleanup and Distribution Sections ---
 
-# Need the trailing '--' so perl stops gobbling arguments and - happens
-# to be an alternative end of line seperator on VMS so we quote it
-    return <<'END_OF_DEF';
-POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
-END_OF_DEF
-}
+    my($self, %attribs) = @_;
+    my @m;
+    push(@m, '
+# Delete temporary files but do not touch installed files. We don\'t delete
+# the Makefile here so a later make realclean still has a makefile to use.
+
+clean :: clean_subdirs
+');
+
+    my @files = values %{$self->{XS}}; # .c files from *.xs files
+    my @dirs  = qw(blib);
+
+    # Normally these are all under blib but they might have been
+    # redefined.
+    # XXX normally this would be a good idea, but the Perl core sets
+    # INST_LIB = ../../lib rather than actually installing the files.
+    # So a "make clean" in an ext/ directory would blow away lib.
+    # Until the core is adjusted let's leave this out.
+#     push @dirs, qw($(INST_ARCHLIB) $(INST_LIB)
+#                    $(INST_BIN) $(INST_SCRIPT)
+#                    $(INST_MAN1DIR) $(INST_MAN3DIR)
+#                    $(INST_LIBDIR) $(INST_ARCHLIBDIR) $(INST_AUTODIR) 
+#                    $(INST_STATIC) $(INST_DYNAMIC) $(INST_BOOT)
+#                 );
+                  
+
+    if( $attribs{FILES} ) {
+        # Use @dirs because we don't know what's in here.
+        push @dirs, ref $attribs{FILES}                ?
+                        @{$attribs{FILES}}             :
+                        split /\s+/, $attribs{FILES}   ;
+    }
 
+    push(@files, qw[$(MAKE_APERL_FILE) 
+                    perlmain.c tmon.out mon.out so_locations 
+                    blibdirs.ts pm_to_blib pm_to_blib.ts
+                    *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT)
+                    $(BOOTSTRAP) $(BASEEXT).bso
+                    $(BASEEXT).def lib$(BASEEXT).def
+                    $(BASEEXT).exp $(BASEEXT).x
+                   ]);
 
-=item test_via_harness
+    push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'));
+    push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.ld'));
 
-  my $command = $mm->test_via_harness($perl, $tests);
+    # core files
+    push(@files, qw[core core.*perl.*.? *perl.core]);
+    push(@files, map { "core." . "[0-9]"x$_ } (1..5));
 
-Returns a $command line which runs the given set of $tests with
-Test::Harness and the given $perl.
+    # OS specific things to clean up.  Use @dirs since we don't know
+    # what might be in here.
+    push @dirs, $self->extra_clean_files;
 
-Used on the t/*.t files.
+    # Occasionally files are repeated several times from different sources
+    { my(%f) = map { ($_ => 1) } @files; @files = keys %f; }
+    { my(%d) = map { ($_ => 1) } @dirs;  @dirs  = keys %d; }
 
-=cut
+    push @m, map "\t$_\n", $self->split_command('- $(RM_F)',  @files);
+    push @m, map "\t$_\n", $self->split_command('- $(RM_RF)', @dirs);
 
-sub test_via_harness {
-    my($self, $perl, $tests) = @_;
+    # Leave Makefile.old around for realclean
+    push @m, <<'MAKE';
+       - $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)
+MAKE
 
-    return qq{\t$perl "-MExtUtils::Command::MM" }.
-           qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n};
+    push(@m, "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
+
+    join("", @m);
 }
 
-=item test_via_script
 
-  my $command = $mm->test_via_script($perl, $script);
+=head3 clean_subdirs_target
 
-Returns a $command line which just runs a single test without
-Test::Harness.  No checks are done on the results, they're just
-printed.
+  my $make_frag = $MM->clean_subdirs_target;
 
-Used for test.pl, since they don't always follow Test::Harness
-formatting.
+Returns the clean_subdirs target.  This is used by the clean target to
+call clean on any subdirectories which contain Makefiles.
 
 =cut
 
-sub test_via_script {
-    my($self, $perl, $script) = @_;
-    return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n};
+sub clean_subdirs_target {
+    my($self) = shift;
+
+    # No subdirectories, no cleaning.
+    return <<'NOOP_FRAG' unless @{$self->{DIR}};
+clean_subdirs :
+       $(NOECHO) $(NOOP)
+NOOP_FRAG
+
+
+    my $clean = "clean_subdirs :\n";
+
+    for my $dir (@{$self->{DIR}}) {
+        my $subclean = $self->oneliner(sprintf <<'CODE', $dir);
+chdir '%s';  system '$(MAKE) clean' if -f '$(FIRST_MAKEFILE)';
+CODE
+
+        $clean .= "\t$subclean\n";
+    }
+
+    return $clean;
 }
 
-=item libscan
 
-  my $wanted = $self->libscan($path);
+=head3 dir_target
 
-Takes a path to a file or dir and returns an empty string if we don't
-want to include this file in the library.  Otherwise it returns the
-the $path unchanged.
+    my $make_frag = $mm->dir_target(@directories);
 
-Mainly used to exclude RCS, CVS, and SCCS directories from
-installation.
+Generates targets to create the specified directories and set its
+permission to 0755.
+
+Because depending on a directory to just ensure it exists doesn't work
+too well (the modified time changes too often) dir_target() creates a
+.exists file in the created directory.  It is this you should depend on.
+For portability purposes you should use the $(DIRFILESEP) macro rather
+than a '/' to seperate the directory from the file.
+
+    yourdirectory$(DIRFILESEP).exists
 
 =cut
 
-sub libscan {
-    my($self,$path) = @_;
-    my($dirs,$file) = ($self->splitpath($path))[1,2];
-    return '' if grep /^RCS|CVS|SCCS|\.svn$/, 
-                     $self->splitdir($dirs), $file;
+sub dir_target {
+    my($self, @dirs) = @_;
 
-    return $path;
+    my $make = '';
+    foreach my $dir (@dirs) {
+        $make .= sprintf <<'MAKE', ($dir) x 7;
+%s$(DFSEP).exists :: Makefile.PL
+       $(NOECHO) $(MKPATH) %s
+       $(NOECHO) $(CHMOD) 755 %s
+       $(NOECHO) $(TOUCH) %s$(DFSEP).exists
+
+MAKE
+
+    }
+
+    return $make;
 }
 
-=item tool_autosplit
 
-Defines a simple perl call that runs autosplit. May be deprecated by
-pm_to_blib soon.
+=head3 distdir
+
+Defines the scratch directory target that will hold the distribution
+before tar-ing (or shar-ing).
 
 =cut
 
-sub tool_autosplit {
-    my($self, %attribs) = @_;
+# For backwards compatibility.
+*dist_dir = *distdir;
 
-    my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' 
-                                  : '';
+sub distdir {
+    my($self) = shift;
 
-    my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen);
-use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)
-PERL_CODE
+    my $meta_target = $self->{NO_META} ? '' : 'distmeta';
+    my $sign_target = !$self->{SIGN}   ? '' : 'distsignature';
 
-    return sprintf <<'MAKE_FRAG', $asplit;
-# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
-AUTOSPLITFILE = %s
+    return sprintf <<'MAKE_FRAG', $meta_target, $sign_target;
+create_distdir :
+       $(RM_RF) $(DISTVNAME)
+       $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
+               -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
+
+distdir : create_distdir %s %s
+       $(NOECHO) $(NOOP)
 
 MAKE_FRAG
 
 }
 
 
-=item all_target
+=head3 dist_test
 
-Generate the default target 'all'.
+Defines a target that produces the distribution in the
+scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
+subdirectory.
 
 =cut
 
-sub all_target {
-    my $self = shift;
+sub dist_test {
+    my($self) = shift;
 
-    return <<'MAKE_EXT';
-all :: pure_all
-       $(NOECHO) $(NOOP)
-MAKE_EXT
+    my $mpl_args = join " ", map qq["$_"], @ARGV;
 
-}
+    my $test = $self->cd('$(DISTVNAME)',
+                         '$(ABSPERLRUN) Makefile.PL '.$mpl_args,
+                         '$(MAKE) $(PASTHRU)',
+                         '$(MAKE) test $(PASTHRU)'
+                        );
+
+    return sprintf <<'MAKE_FRAG', $test;
+disttest : distdir
+       %s
 
+MAKE_FRAG
 
-=item metafile_target
 
-    my $target = $mm->metafile_target;
+}
 
-Generate the metafile target.
 
-Writes the file META.yml, YAML encoded meta-data about the module.  The
-format follows Module::Build's as closely as possible.  Additionally, we
-include:
+=head3 dynamic (o)
 
-    version_from
-    installdirs
+Defines the dynamic target.
 
 =cut
 
-sub metafile_target {
-    my $self = shift;
-
-    my $prereq_pm = '';
-    while( my($mod, $ver) = each %{$self->{PREREQ_PM}} ) {
-        $prereq_pm .= sprintf "    %-30s %s\n", "$mod:", $ver;
-    }
-    
-    my $meta = <<YAML;
-#XXXXXXX This is a prototype!!!  It will change in the future!!! XXXXX#
-name:         $self->{DISTNAME}
-version:      $self->{VERSION}
-version_from: $self->{VERSION_FROM}
-installdirs:  $self->{INSTALLDIRS}
-requires:
-$prereq_pm
-distribution_type: module
-generated_by: ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION
-YAML
-
-    my @write_meta = $self->echo($meta, 'META.yml');
-    return sprintf <<'MAKE_FRAG', join "\n\t", @write_meta;
-metafile :
-       %s
-MAKE_FRAG
+sub dynamic {
+# --- Dynamic Loading Sections ---
 
+    my($self) = shift;
+    '
+dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
+       $(NOECHO) $(NOOP)
+';
 }
 
 
-=item metafile_addtomanifest_target
+=head3 makemakerdflt_target
 
-  my $target = $mm->metafile_addtomanifest_target
+  my $make_frag = $mm->makemakerdflt_target
 
-Adds the META.yml file to the MANIFEST.
+Returns a make fragment with the makemakerdeflt_target specified.
+This target is the first target in the Makefile, is the default target
+and simply points off to 'all' just in case any make variant gets
+confused or something gets snuck in before the real 'all' target.
 
 =cut
 
-sub metafile_addtomanifest_target {
-    my $self = shift;
-
-    my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
-maniadd({q{META.yml} => q{Module meta-data in YAML}});
-CODE
-
-    return sprintf <<'MAKE_FRAG', $add_meta;
-metafile_addtomanifest:
-       $(NOECHO) %s
+sub makemakerdflt_target {
+    return <<'MAKE_FRAG';
+makemakerdflt : all
+       $(NOECHO) $(NOOP)
 MAKE_FRAG
 
 }
 
 
-=back
+=head3 manifypods_target
 
-=head2 Abstract methods
+  my $manifypods_target = $self->manifypods_target;
 
-Methods which cannot be made cross-platform and each subclass will
-have to do their own implementation.
+Generates the manifypods target.  This target generates man pages from
+all POD files in MAN1PODS and MAN3PODS.
 
-=over 4
+=cut
 
-=item oneliner
+sub manifypods_target {
+    my($self) = shift;
 
-  my $oneliner = $MM->oneliner($perl_code);
-  my $oneliner = $MM->oneliner($perl_code, \@switches);
+    my $man1pods      = '';
+    my $man3pods      = '';
+    my $dependencies  = '';
 
-This will generate a perl one-liner safe for the particular platform
-you're on based on the given $perl_code and @switches (a -e is
-assumed) suitable for using in a make target.  It will use the proper
-shell quoting and escapes.
+    # populate manXpods & dependencies:
+    foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) {
+        $dependencies .= " \\\n\t$name";
+    }
 
-$(PERLRUN) will be used as perl.
+    my $manify = <<END;
+manifypods : pure_all $dependencies
+END
 
-Any newlines in $perl_code will be escaped.  Leading and trailing
-newlines will be stripped.  Makes this idiom much easier:
+    my @man_cmds;
+    foreach my $section (qw(1 3)) {
+        my $pods = $self->{"MAN${section}PODS"};
+        push @man_cmds, $self->split_command(<<CMD, %$pods);
+       \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW)
+CMD
+    }
 
-    my $code = $MM->oneliner(<<'CODE', [...switches...]);
-some code here
-another line here
-CODE
+    $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
+    $manify .= join '', map { "$_\n" } @man_cmds;
 
-Usage might be something like:
+    return $manify;
+}
 
-    # an echo emulation
-    $oneliner = $MM->oneliner('print "Foo\n"');
-    $make = '$oneliner > somefile';
 
-All dollar signs must be doubled in the $perl_code if you expect them
-to be interpreted normally, otherwise it will be considered a make
-macro.  Also remember to quote make macros else it might be used as a
-bareword.  For example:
+=head3 metafile_target
 
-    # Assign the value of the $(VERSION_FROM) make macro to $vf.
-    $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"');
+    my $target = $mm->metafile_target;
 
-Its currently very simple and may be expanded sometime in the figure
-to include more flexible code and switches.
+Generate the metafile target.
 
+Writes the file META.yml YAML encoded meta-data about the module in
+the distdir.  The format follows Module::Build's as closely as
+possible.
 
-=item B<quote_literal>
+=cut
 
-    my $safe_text = $MM->quote_literal($text);
+sub metafile_target {
+    my $self = shift;
 
-This will quote $text so it is interpreted literally in the shell.
+    return <<'MAKE_FRAG' if $self->{NO_META};
+metafile :
+       $(NOECHO) $(NOOP)
+MAKE_FRAG
 
-For example, on Unix this would escape any single-quotes in $text and
-put single-quotes around the whole thing.
+    my @metadata   = $self->metafile_data(
+        $self->{META_ADD}   || {},
+        $self->{META_MERGE} || {},
+    );
+    my $meta       = $self->metafile_file(@metadata);
+    my @write_meta = $self->echo($meta, 'META_new.yml');
 
+    return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta);
+metafile : create_distdir
+       $(NOECHO) $(ECHO) Generating META.yml
+       %s
+       -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml
+MAKE_FRAG
 
-=item B<escape_newlines>
+}
 
-    my $escaped_text = $MM->escape_newlines($text);
 
-Shell escapes newlines in $text.
+=begin private
 
+=head3 _sort_pairs
 
-=item max_exec_len
+    my @pairs = _sort_pairs($sort_sub, \%hash);
 
-    my $max_exec_len = $MM->max_exec_len;
+Sorts the pairs of a hash based on keys ordered according 
+to C<$sort_sub>.
 
-Calculates the maximum command size the OS can exec.  Effectively,
-this is the max size of a shell command line.
+=end private
 
-=for _private
-$self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes.
+=cut
 
-=item B<init_others>
+sub _sort_pairs {
+    my $sort  = shift;
+    my $pairs = shift;
+    return map  { $_ => $pairs->{$_} }
+           sort $sort
+           keys %$pairs;
+}
 
-    $MM->init_others();
 
-Initializes the macro definitions used by tools_other() and places them
-in the $MM object.
+# Taken from Module::Build::Base
+sub _hash_merge {
+    my ($self, $h, $k, $v) = @_;
+    if (ref $h->{$k} eq 'ARRAY') {
+        push @{$h->{$k}}, ref $v ? @$v : $v;
+    } elsif (ref $h->{$k} eq 'HASH') {
+        $self->_hash_merge($h->{$k}, $_, $v->{$_}) foreach keys %$v;
+    } else {
+        $h->{$k} = $v;
+    }
+}
 
-If there is no description, its the same as the parameter to
-WriteMakefile() documented in ExtUtils::MakeMaker.
 
-Defines at least these macros.
+=head3 metafile_data
 
-  Macro             Description
+    my @metadata_pairs = $mm->metafile_data(\%meta_add, \%meta_merge);
 
-  NOOP              Do nothing
-  NOECHO            Tell make not to display the command itself
+Returns the data which MakeMaker turns into the META.yml file.
 
-  MAKEFILE
-  FIRST_MAKEFILE
-  MAKEFILE_OLD
-  MAKE_APERL_FILE   File used by MAKE_APERL
+Values of %meta_add will overwrite any existing metadata in those
+keys.  %meta_merge will be merged with them.
 
-  SHELL             Program used to run
-                    shell commands
+=cut
 
-  ECHO              Print text adding a newline on the end
-  RM_F              Remove a file 
-  RM_RF             Remove a directory          
-  TOUCH             Update a file's timestamp   
-  TEST_F            Test for a file's existence 
-  CP                Copy a file                 
-  MV                Move a file                 
-  CHMOD             Change permissions on a     
-                    file
+sub metafile_data {
+    my $self = shift;
+    my($meta_add, $meta_merge) = @_;
+
+    # The order in which standard meta keys should be written.
+    my @meta_order = qw(
+        name
+        version
+        abstract
+        author
+        license
+        distribution_type
+
+        configure_requires
+        build_requires
+        requires
+
+        resources
+
+        provides
+        no_index
+
+        generated_by
+        meta-spec
+    );
+
+    my %meta = (
+        name         => $self->{DISTNAME},
+        version      => $self->{VERSION},
+        abstract     => $self->{ABSTRACT},
+        license      => $self->{LICENSE} || 'unknown',
+        distribution_type => $self->{PM} ? 'module' : 'script',
+
+        configure_requires => {
+            'ExtUtils::MakeMaker'       => 0
+        },
+
+        no_index     => {
+            directory   => [qw(t inc)]
+        },
+
+        generated_by => "ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION",
+        'meta-spec'  => {
+            url         => 'http://module-build.sourceforge.net/META-spec-v1.4.html', 
+            version     => 1.4
+        },
+    );
+
+    # The author key is required and it takes a list.
+    $meta{author}   = defined $self->{AUTHOR}    ? [$self->{AUTHOR}] : [];
+
+    $meta{requires} = $self->{PREREQ_PM} if defined $self->{PREREQ_PM};
+    $meta{requires}{perl} = $self->{MIN_PERL_VERSION} if $self->{MIN_PERL_VERSION};
+
+    while( my($key, $val) = each %$meta_add ) {
+        $meta{$key} = $val;
+    }
 
-  UMASK_NULL        Nullify umask
-  DEV_NULL          Supress all command output
+    while( my($key, $val) = each %$meta_merge ) {
+        $self->_hash_merge(\%meta, $key, $val);
+    }
 
-=item init_DIRFILESEP
+    my @meta_pairs;
 
-  $MM->init_DIRFILESEP;
-  my $dirfilesep = $MM->{DIRFILESEP};
+    # Put the standard keys first in the proper order.
+    for my $key (@meta_order) {
+        next unless exists $meta{$key};
 
-Initializes the DIRFILESEP macro which is the seperator between the
-directory and filename in a filepath.  ie. / on Unix, \ on Win32 and
-nothing on VMS.
+        push @meta_pairs, $key, delete $meta{$key};
+    }
 
-For example:
+    # Then tack everything else onto the end, alpha sorted.
+    for my $key (sort {lc $a cmp lc $b} keys %meta) {
+        push @meta_pairs, $key, $meta{$key};
+    }
 
-    # instead of $(INST_ARCHAUTODIR)/extralibs.ld
-    $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld
+    return @meta_pairs
+}
 
-Something of a hack but it prevents a lot of code duplication between
-MM_* variants.
+=begin private
 
-Do not use this as a seperator between directories.  Some operating
-systems use different seperators between subdirectories as between
-directories and filenames (for example:  VOLUME:[dir1.dir2]file on VMS).
+=head3 _dump_hash
 
-=item init_linker
+    $yaml = _dump_hash(\%options, %hash);
 
-    $mm->init_linker;
+Implements a fake YAML dumper for a hash given
+as a list of pairs. No quoting/escaping is done. Keys
+are supposed to be strings. Values are undef, strings, 
+hash refs or array refs of strings.
 
-Initialize macros which have to do with linking.
+Supported options are:
 
-PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic
-extensions.
+    delta => STR - indentation delta
+    use_header => BOOL - whether to include a YAML header
+    indent => STR - a string of spaces 
+          default: ''
 
-PERL_ARCHIVE_AFTER: path to a library which should be put on the
-linker command line I<after> the external libraries to be linked to
-dynamic extensions.  This may be needed if the linker is one-pass, and
-Perl includes some overrides for C RTL functions, such as malloc().
+    max_key_length => INT - maximum key length used to align
+        keys and values of the same hash
+        default: 20
+    key_sort => CODE - a sort sub 
+            It may be undef, which means no sorting by keys
+        default: sub { lc $a cmp lc $b }
 
-EXPORT_LIST: name of a file that is passed to linker to define symbols
-to be exported.
+    customs => HASH - special options for certain keys 
+           (whose values are hashes themselves)
+        may contain: max_key_length, key_sort, customs
 
-Some OSes do not need these in which case leave it blank.
+=end private
 
+=cut
 
-=item init_platform
+sub _dump_hash {
+    croak "first argument should be a hash ref" unless ref $_[0] eq 'HASH';
+    my $options = shift;
+    my %hash = @_;
+
+    # Use a list to preserve order.
+    my @pairs;
+
+    my $k_sort 
+        = exists $options->{key_sort} ? $options->{key_sort} 
+                                      : sub { lc $a cmp lc $b };
+    if ($k_sort) {
+        croak "'key_sort' should be a coderef" unless ref $k_sort eq 'CODE';
+        @pairs = _sort_pairs($k_sort, \%hash);
+    } else { # list of pairs, no sorting
+        @pairs = @_;
+    }
 
-    $mm->init_platform
+    my $yaml     = $options->{use_header} ? "--- #YAML:1.0\n" : '';
+    my $indent   = $options->{indent} || '';
+    my $k_length = min(
+        ($options->{max_key_length} || 20),
+        max(map { length($_) + 1 } grep { !ref $hash{$_} } keys %hash)
+    );
+    my $customs  = $options->{customs} || {};
+
+    # printf format for key
+    my $k_format = "%-${k_length}s";
+
+    while( @pairs ) {
+        my($key, $val) = splice @pairs, 0, 2;
+        $val = '~' unless defined $val;
+        if(ref $val eq 'HASH') {
+            if ( keys %$val ) {
+                my %k_options = ( # options for recursive call
+                    delta => $options->{delta},
+                    use_header => 0,
+                    indent => $indent . $options->{delta},
+                );
+                if (exists $customs->{$key}) {
+                    my %k_custom = %{$customs->{$key}};
+                    foreach my $k qw(key_sort max_key_length customs) {
+                        $k_options{$k} = $k_custom{$k} if exists $k_custom{$k};
+                    }
+                }
+                $yaml .= $indent . "$key:\n" 
+                  . _dump_hash(\%k_options, %$val);
+            }
+            else {
+                $yaml .= $indent . "$key:  {}\n";
+            }
+        }
+        elsif (ref $val eq 'ARRAY') {
+            if( @$val ) {
+                $yaml .= $indent . "$key:\n";
+
+                for (@$val) {
+                    croak "only nested arrays of non-refs are supported" if ref $_;
+                    $yaml .= $indent . $options->{delta} . "- $_\n";
+                }
+            }
+            else {
+                $yaml .= $indent . "$key:  []\n";
+            }
+        }
+        elsif( ref $val and !blessed($val) ) {
+            croak "only nested hashes, arrays and objects are supported";
+        }
+        else {  # if it's an object, just stringify it
+            $yaml .= $indent . sprintf "$k_format  %s\n", "$key:", $val;
+        }
+    };
 
-Initialize any macros which are for platform specific use only.
+    return $yaml;
 
-A typical one is the version number of your OS specific mocule.
-(ie. MM_Unix_VERSION or MM_VMS_VERSION).
+}
 
-=item platform_constants
+sub blessed {
+    return eval { $_[0]->isa("UNIVERSAL"); };
+}
 
-    my $make_frag = $mm->platform_constants
+sub max {
+    return (sort { $b <=> $a } @_)[0];
+}
 
-Returns a make fragment defining all the macros initialized in
-init_platform() rather than put them in constants().
+sub min {
+    return (sort { $a <=> $b } @_)[0];
+}
+
+=head3 metafile_file
+
+    my $meta_yml = $mm->metafile_file(@metadata_pairs);
+
+Turns the @metadata_pairs into YAML.
+
+This method does not implement a complete YAML dumper, being limited
+to dump a hash with values which are strings, undef's or nested hashes
+and arrays of strings. No quoting/escaping is done.
 
 =cut
 
-sub init_platform {
-    return '';
-}
+sub metafile_file {
+    my $self = shift;
+
+    my %dump_options = (
+        use_header => 1, 
+        delta      => ' ' x 4, 
+        key_sort   => undef,
+    );
+    return _dump_hash(\%dump_options, @_);
 
-sub platform_constants {
-    return '';
 }
 
-=item os_flavor
 
-    my @os_flavor = $mm->os_flavor;
+=head3 distmeta_target
 
-@os_flavor is the style of operating system this is, usually
-corresponding to the MM_*.pm file we're using.  
+    my $make_frag = $mm->distmeta_target;
 
-The first element of @os_flavor is the major family (ie. Unix,
-Windows, VMS, OS/2, MacOS, etc...) and the rest are sub families.
+Generates the distmeta target to add META.yml to the MANIFEST in the
+distdir.
 
-Some examples:
+=cut
 
-    Cygwin98       ('Unix',  'Cygwin', 'Cygwin9x')
-    Windows NT     ('Win32', 'WinNT')
-    Win98          ('Win32', 'Win9x')
-    Linux          ('Unix',  'Linux')
-    MacOS Classic  ('MacOS', 'MacOS Classic')
-    MacOS X        ('Unix',  'Darwin', 'MacOS', 'MacOS X')
-    OS/2           ('OS/2')
+sub distmeta_target {
+    my $self = shift;
+
+    my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
+eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } 
+    or print "Could not add META.yml to MANIFEST: $${'@'}\n"
+CODE
+
+    my $add_meta_to_distdir = $self->cd('$(DISTVNAME)', $add_meta);
+
+    return sprintf <<'MAKE', $add_meta_to_distdir;
+distmeta : create_distdir metafile
+       $(NOECHO) %s
+
+MAKE
+
+}
+
+
+=head3 realclean (o)
+
+Defines the realclean target.
+
+=cut
+
+sub realclean {
+    my($self, %attribs) = @_;
+
+    my @dirs  = qw($(DISTVNAME));
+    my @files = qw($(FIRST_MAKEFILE) $(MAKEFILE_OLD));
+
+    # Special exception for the perl core where INST_* is not in blib.
+    # This cleans up the files built from the ext/ directory (all XS).
+    if( $self->{PERL_CORE} ) {
+       push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR));
+        push @files, values %{$self->{PM}};
+    }
+
+    if( $self->has_link_code ){
+        push @files, qw($(OBJECT));
+    }
+
+    if( $attribs{FILES} ) {
+        if( ref $attribs{FILES} ) {
+            push @dirs, @{ $attribs{FILES} };
+        }
+        else {
+            push @dirs, split /\s+/, $attribs{FILES};
+        }
+    }
+
+    # Occasionally files are repeated several times from different sources
+    { my(%f) = map { ($_ => 1) } @files;  @files = keys %f; }
+    { my(%d) = map { ($_ => 1) } @dirs;   @dirs  = keys %d; }
+
+    my $rm_cmd  = join "\n\t", map { "$_" } 
+                    $self->split_command('- $(RM_F)',  @files);
+    my $rmf_cmd = join "\n\t", map { "$_" } 
+                    $self->split_command('- $(RM_RF)', @dirs);
+
+    my $m = sprintf <<'MAKE', $rm_cmd, $rmf_cmd;
+# Delete temporary files (via clean) and also delete dist files
+realclean purge ::  clean realclean_subdirs
+       %s
+       %s
+MAKE
+
+    $m .= "\t$attribs{POSTOP}\n" if $attribs{POSTOP};
+
+    return $m;
+}
+
+
+=head3 realclean_subdirs_target
+
+  my $make_frag = $MM->realclean_subdirs_target;
+
+Returns the realclean_subdirs target.  This is used by the realclean
+target to call realclean on any subdirectories which contain Makefiles.
+
+=cut
+
+sub realclean_subdirs_target {
+    my $self = shift;
+
+    return <<'NOOP_FRAG' unless @{$self->{DIR}};
+realclean_subdirs :
+       $(NOECHO) $(NOOP)
+NOOP_FRAG
+
+    my $rclean = "realclean_subdirs :\n";
+
+    foreach my $dir (@{$self->{DIR}}) {
+        foreach my $makefile ('$(MAKEFILE_OLD)', '$(FIRST_MAKEFILE)' ) {
+            my $subrclean .= $self->oneliner(sprintf <<'CODE', $dir, ($makefile) x 2);
+chdir '%s';  system '$(MAKE) $(USEMAKEFILE) %s realclean' if -f '%s';
+CODE
+
+            $rclean .= sprintf <<'RCLEAN', $subrclean;
+       - %s
+RCLEAN
+
+        }
+    }
+
+    return $rclean;
+}
+
+
+=head3 signature_target
+
+    my $target = $mm->signature_target;
+
+Generate the signature target.
+
+Writes the file SIGNATURE with "cpansign -s".
+
+=cut
+
+sub signature_target {
+    my $self = shift;
+
+    return <<'MAKE_FRAG';
+signature :
+       cpansign -s
+MAKE_FRAG
+
+}
+
+
+=head3 distsignature_target
+
+    my $make_frag = $mm->distsignature_target;
+
+Generates the distsignature target to add SIGNATURE to the MANIFEST in the
+distdir.
+
+=cut
+
+sub distsignature_target {
+    my $self = shift;
+
+    my $add_sign = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
+eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } 
+    or print "Could not add SIGNATURE to MANIFEST: $${'@'}\n"
+CODE
+
+    my $sign_dist        = $self->cd('$(DISTVNAME)' => 'cpansign -s');
+
+    # cpansign -s complains if SIGNATURE is in the MANIFEST yet does not
+    # exist
+    my $touch_sig        = $self->cd('$(DISTVNAME)' => '$(TOUCH) SIGNATURE');
+    my $add_sign_to_dist = $self->cd('$(DISTVNAME)' => $add_sign );
+
+    return sprintf <<'MAKE', $add_sign_to_dist, $touch_sig, $sign_dist
+distsignature : create_distdir
+       $(NOECHO) %s
+       $(NOECHO) %s
+       %s
+
+MAKE
+
+}
+
+
+=head3 special_targets
+
+  my $make_frag = $mm->special_targets
+
+Returns a make fragment containing any targets which have special
+meaning to make.  For example, .SUFFIXES and .PHONY.
+
+=cut
+
+sub special_targets {
+    my $make_frag = <<'MAKE_FRAG';
+.SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
+
+.PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir
+
+MAKE_FRAG
+
+    $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT};
+.NO_CONFIG_REC: Makefile
+
+MAKE_FRAG
+
+    return $make_frag;
+}
+
+
+
+
+=head2 Init methods
+
+Methods which help initialize the MakeMaker object and macros.
+
+
+=head3 init_ABSTRACT
+
+    $mm->init_ABSTRACT
+
+=cut
+
+sub init_ABSTRACT {
+    my $self = shift;
+
+    if( $self->{ABSTRACT_FROM} and $self->{ABSTRACT} ) {
+        warn "Both ABSTRACT_FROM and ABSTRACT are set.  ".
+             "Ignoring ABSTRACT_FROM.\n";
+        return;
+    }
+
+    if ($self->{ABSTRACT_FROM}){
+        $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
+            carp "WARNING: Setting ABSTRACT via file ".
+                 "'$self->{ABSTRACT_FROM}' failed\n";
+    }
+}
+
+=head3 init_INST
+
+    $mm->init_INST;
+
+Called by init_main.  Sets up all INST_* variables except those related
+to XS code.  Those are handled in init_xs.
+
+=cut
+
+sub init_INST {
+    my($self) = shift;
+
+    $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
+    $self->{INST_BIN}     ||= $self->catdir($Curdir,'blib','bin');
+
+    # INST_LIB typically pre-set if building an extension after
+    # perl has been built and installed. Setting INST_LIB allows
+    # you to build directly into, say $Config{privlibexp}.
+    unless ($self->{INST_LIB}){
+       if ($self->{PERL_CORE}) {
+            if (defined $Cross::platform) {
+                $self->{INST_LIB} = $self->{INST_ARCHLIB} = 
+                  $self->catdir($self->{PERL_LIB},"..","xlib",
+                                     $Cross::platform);
+            }
+            else {
+                $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
+            }
+       } else {
+           $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
+       }
+    }
+
+    my @parentdir = split(/::/, $self->{PARENT_NAME});
+    $self->{INST_LIBDIR}      = $self->catdir('$(INST_LIB)',     @parentdir);
+    $self->{INST_ARCHLIBDIR}  = $self->catdir('$(INST_ARCHLIB)', @parentdir);
+    $self->{INST_AUTODIR}     = $self->catdir('$(INST_LIB)', 'auto', 
+                                              '$(FULLEXT)');
+    $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
+                                              '$(FULLEXT)');
+
+    $self->{INST_SCRIPT}  ||= $self->catdir($Curdir,'blib','script');
+
+    $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
+    $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
+
+    return 1;
+}
+
+
+=head3 init_INSTALL
+
+    $mm->init_INSTALL;
+
+Called by init_main.  Sets up all INSTALL_* variables (except
+INSTALLDIRS) and *PREFIX.
+
+=cut
+
+sub init_INSTALL {
+    my($self) = shift;
+
+    if( $self->{ARGS}{INSTALL_BASE} and $self->{ARGS}{PREFIX} ) {
+        die "Only one of PREFIX or INSTALL_BASE can be given.  Not both.\n";
+    }
+
+    if( $self->{ARGS}{INSTALL_BASE} ) {
+        $self->init_INSTALL_from_INSTALL_BASE;
+    }
+    else {
+        $self->init_INSTALL_from_PREFIX;
+    }
+}
+
+
+=head3 init_INSTALL_from_PREFIX
+
+  $mm->init_INSTALL_from_PREFIX;
+
+=cut
+
+sub init_INSTALL_from_PREFIX {
+    my $self = shift;
+
+    $self->init_lib2arch;
+
+    # There are often no Config.pm defaults for these new man variables so 
+    # we fall back to the old behavior which is to use installman*dir
+    foreach my $num (1, 3) {
+        my $k = 'installsiteman'.$num.'dir';
+
+        $self->{uc $k} ||= uc "\$(installman${num}dir)"
+          unless $Config{$k};
+    }
+
+    foreach my $num (1, 3) {
+        my $k = 'installvendorman'.$num.'dir';
+
+        unless( $Config{$k} ) {
+            $self->{uc $k}  ||= $Config{usevendorprefix}
+                              ? uc "\$(installman${num}dir)"
+                              : '';
+        }
+    }
+
+    $self->{INSTALLSITEBIN} ||= '$(INSTALLBIN)'
+      unless $Config{installsitebin};
+    $self->{INSTALLSITESCRIPT} ||= '$(INSTALLSCRIPT)'
+      unless $Config{installsitescript};
+
+    unless( $Config{installvendorbin} ) {
+        $self->{INSTALLVENDORBIN} ||= $Config{usevendorprefix} 
+                                    ? $Config{installbin}
+                                    : '';
+    }
+    unless( $Config{installvendorscript} ) {
+        $self->{INSTALLVENDORSCRIPT} ||= $Config{usevendorprefix}
+                                       ? $Config{installscript}
+                                       : '';
+    }
+
+
+    my $iprefix = $Config{installprefixexp} || $Config{installprefix} || 
+                  $Config{prefixexp}        || $Config{prefix} || '';
+    my $vprefix = $Config{usevendorprefix}  ? $Config{vendorprefixexp} : '';
+    my $sprefix = $Config{siteprefixexp}    || '';
+
+    # 5.005_03 doesn't have a siteprefix.
+    $sprefix = $iprefix unless $sprefix;
+
+
+    $self->{PREFIX}       ||= '';
+
+    if( $self->{PREFIX} ) {
+        @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
+          ('$(PREFIX)') x 3;
+    }
+    else {
+        $self->{PERLPREFIX}   ||= $iprefix;
+        $self->{SITEPREFIX}   ||= $sprefix;
+        $self->{VENDORPREFIX} ||= $vprefix;
+
+        # Lots of MM extension authors like to use $(PREFIX) so we
+        # put something sensible in there no matter what.
+        $self->{PREFIX} = '$('.uc $self->{INSTALLDIRS}.'PREFIX)';
+    }
+
+    my $arch    = $Config{archname};
+    my $version = $Config{version};
+
+    # default style
+    my $libstyle = $Config{installstyle} || 'lib/perl5';
+    my $manstyle = '';
+
+    if( $self->{LIBSTYLE} ) {
+        $libstyle = $self->{LIBSTYLE};
+        $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
+    }
+
+    # Some systems, like VOS, set installman*dir to '' if they can't
+    # read man pages.
+    for my $num (1, 3) {
+        $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
+          unless $Config{'installman'.$num.'dir'};
+    }
+
+    my %bin_layouts = 
+    (
+        bin         => { s => $iprefix,
+                         t => 'perl',
+                         d => 'bin' },
+        vendorbin   => { s => $vprefix,
+                         t => 'vendor',
+                         d => 'bin' },
+        sitebin     => { s => $sprefix,
+                         t => 'site',
+                         d => 'bin' },
+        script      => { s => $iprefix,
+                         t => 'perl',
+                         d => 'bin' },
+        vendorscript=> { s => $vprefix,
+                         t => 'vendor',
+                         d => 'bin' },
+        sitescript  => { s => $sprefix,
+                         t => 'site',
+                         d => 'bin' },
+    );
+    
+    my %man_layouts =
+    (
+        man1dir         => { s => $iprefix,
+                             t => 'perl',
+                             d => 'man/man1',
+                             style => $manstyle, },
+        siteman1dir     => { s => $sprefix,
+                             t => 'site',
+                             d => 'man/man1',
+                             style => $manstyle, },
+        vendorman1dir   => { s => $vprefix,
+                             t => 'vendor',
+                             d => 'man/man1',
+                             style => $manstyle, },
+
+        man3dir         => { s => $iprefix,
+                             t => 'perl',
+                             d => 'man/man3',
+                             style => $manstyle, },
+        siteman3dir     => { s => $sprefix,
+                             t => 'site',
+                             d => 'man/man3',
+                             style => $manstyle, },
+        vendorman3dir   => { s => $vprefix,
+                             t => 'vendor',
+                             d => 'man/man3',
+                             style => $manstyle, },
+    );
+
+    my %lib_layouts =
+    (
+        privlib     => { s => $iprefix,
+                         t => 'perl',
+                         d => '',
+                         style => $libstyle, },
+        vendorlib   => { s => $vprefix,
+                         t => 'vendor',
+                         d => '',
+                         style => $libstyle, },
+        sitelib     => { s => $sprefix,
+                         t => 'site',
+                         d => 'site_perl',
+                         style => $libstyle, },
+        
+        archlib     => { s => $iprefix,
+                         t => 'perl',
+                         d => "$version/$arch",
+                         style => $libstyle },
+        vendorarch  => { s => $vprefix,
+                         t => 'vendor',
+                         d => "$version/$arch",
+                         style => $libstyle },
+        sitearch    => { s => $sprefix,
+                         t => 'site',
+                         d => "site_perl/$version/$arch",
+                         style => $libstyle },
+    );
+
+
+    # Special case for LIB.
+    if( $self->{LIB} ) {
+        foreach my $var (keys %lib_layouts) {
+            my $Installvar = uc "install$var";
+
+            if( $var =~ /arch/ ) {
+                $self->{$Installvar} ||= 
+                  $self->catdir($self->{LIB}, $Config{archname});
+            }
+            else {
+                $self->{$Installvar} ||= $self->{LIB};
+            }
+        }
+    }
+
+    my %type2prefix = ( perl    => 'PERLPREFIX',
+                        site    => 'SITEPREFIX',
+                        vendor  => 'VENDORPREFIX'
+                      );
+
+    my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
+    while( my($var, $layout) = each(%layouts) ) {
+        my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
+        my $r = '$('.$type2prefix{$t}.')';
+
+        print STDERR "Prefixing $var\n" if $Verbose >= 2;
+
+        my $installvar = "install$var";
+        my $Installvar = uc $installvar;
+        next if $self->{$Installvar};
+
+        $d = "$style/$d" if $style;
+        $self->prefixify($installvar, $s, $r, $d);
+
+        print STDERR "  $Installvar == $self->{$Installvar}\n" 
+          if $Verbose >= 2;
+    }
+
+    # Generate these if they weren't figured out.
+    $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
+    $self->{VENDORLIBEXP}  ||= $self->{INSTALLVENDORLIB};
+
+    return 1;
+}
+
+
+=head3 init_from_INSTALL_BASE
+
+    $mm->init_from_INSTALL_BASE
+
+=cut
+
+my %map = (
+           lib      => [qw(lib perl5)],
+           arch     => [('lib', 'perl5', $Config{archname})],
+           bin      => [qw(bin)],
+           man1dir  => [qw(man man1)],
+           man3dir  => [qw(man man3)]
+          );
+$map{script} = $map{bin};
+
+sub init_INSTALL_from_INSTALL_BASE {
+    my $self = shift;
+
+    @{$self}{qw(PREFIX VENDORPREFIX SITEPREFIX PERLPREFIX)} = 
+                                                         '$(INSTALL_BASE)';
+
+    my %install;
+    foreach my $thing (keys %map) {
+        foreach my $dir (('', 'SITE', 'VENDOR')) {
+            my $uc_thing = uc $thing;
+            my $key = "INSTALL".$dir.$uc_thing;
+
+            $install{$key} ||= 
+              $self->catdir('$(INSTALL_BASE)', @{$map{$thing}});
+        }
+    }
+
+    # Adjust for variable quirks.
+    $install{INSTALLARCHLIB} ||= delete $install{INSTALLARCH};
+    $install{INSTALLPRIVLIB} ||= delete $install{INSTALLLIB};
+
+    foreach my $key (keys %install) {
+        $self->{$key} ||= $install{$key};
+    }
+
+    return 1;
+}
+
+
+=head3 init_VERSION  I<Abstract>
+
+    $mm->init_VERSION
+
+Initialize macros representing versions of MakeMaker and other tools
+
+MAKEMAKER: path to the MakeMaker module.
+
+MM_VERSION: ExtUtils::MakeMaker Version
+
+MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards 
+             compat)
+
+VERSION: version of your module
+
+VERSION_MACRO: which macro represents the version (usually 'VERSION')
+
+VERSION_SYM: like version but safe for use as an RCS revision number
+
+DEFINE_VERSION: -D line to set the module version when compiling
+
+XS_VERSION: version in your .xs file.  Defaults to $(VERSION)
+
+XS_VERSION_MACRO: which macro represents the XS version.
+
+XS_DEFINE_VERSION: -D line to set the xs version when compiling.
+
+Called by init_main.
+
+=cut
+
+sub init_VERSION {
+    my($self) = shift;
+
+    $self->{MAKEMAKER}  = $ExtUtils::MakeMaker::Filename;
+    $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION;
+    $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision;
+    $self->{VERSION_FROM} ||= '';
+
+    if ($self->{VERSION_FROM}){
+        $self->{VERSION} = $self->parse_version($self->{VERSION_FROM});
+        if( $self->{VERSION} eq 'undef' ) {
+            carp("WARNING: Setting VERSION via file ".
+                 "'$self->{VERSION_FROM}' failed\n");
+        }
+    }
+
+    # strip blanks
+    if (defined $self->{VERSION}) {
+        $self->{VERSION} =~ s/^\s+//;
+        $self->{VERSION} =~ s/\s+$//;
+    }
+    else {
+        $self->{VERSION} = '';
+    }
+
+
+    $self->{VERSION_MACRO}  = 'VERSION';
+    ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
+    $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"';
+
+
+    # Graham Barr and Paul Marquess had some ideas how to ensure
+    # version compatibility between the *.pm file and the
+    # corresponding *.xs file. The bottomline was, that we need an
+    # XS_VERSION macro that defaults to VERSION:
+    $self->{XS_VERSION} ||= $self->{VERSION};
+
+    $self->{XS_VERSION_MACRO}  = 'XS_VERSION';
+    $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"';
+
+}
+
+
+=head3 init_others  I<Abstract>
+
+    $MM->init_others();
+
+Initializes the macro definitions used by tools_other() and places them
+in the $MM object.
+
+If there is no description, its the same as the parameter to
+WriteMakefile() documented in ExtUtils::MakeMaker.
+
+Defines at least these macros.
+
+  Macro             Description
+
+  NOOP              Do nothing
+  NOECHO            Tell make not to display the command itself
+
+  MAKEFILE
+  FIRST_MAKEFILE
+  MAKEFILE_OLD
+  MAKE_APERL_FILE   File used by MAKE_APERL
+
+  SHELL             Program used to run shell commands
+
+  ECHO              Print text adding a newline on the end
+  RM_F              Remove a file 
+  RM_RF             Remove a directory          
+  TOUCH             Update a file's timestamp   
+  TEST_F            Test for a file's existence 
+  CP                Copy a file                 
+  MV                Move a file                 
+  CHMOD             Change permissions on a     
+                    file
 
-This is used to write code for styles of operating system.  
-See os_flavor_is() for use.
+  UMASK_NULL        Nullify umask
+  DEV_NULL          Suppress all command output
+
+
+=head3 init_DIRFILESEP  I<Abstract>
+
+  $MM->init_DIRFILESEP;
+  my $dirfilesep = $MM->{DIRFILESEP};
+
+Initializes the DIRFILESEP macro which is the seperator between the
+directory and filename in a filepath.  ie. / on Unix, \ on Win32 and
+nothing on VMS.
+
+For example:
+
+    # instead of $(INST_ARCHAUTODIR)/extralibs.ld
+    $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld
+
+Something of a hack but it prevents a lot of code duplication between
+MM_* variants.
+
+Do not use this as a seperator between directories.  Some operating
+systems use different seperators between subdirectories as between
+directories and filenames (for example:  VOLUME:[dir1.dir2]file on VMS).
+
+=head3 init_linker  I<Abstract>
+
+    $mm->init_linker;
+
+Initialize macros which have to do with linking.
+
+PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic
+extensions.
+
+PERL_ARCHIVE_AFTER: path to a library which should be put on the
+linker command line I<after> the external libraries to be linked to
+dynamic extensions.  This may be needed if the linker is one-pass, and
+Perl includes some overrides for C RTL functions, such as malloc().
+
+EXPORT_LIST: name of a file that is passed to linker to define symbols
+to be exported.
+
+Some OSes do not need these in which case leave it blank.
+
+
+=head3 init_platform
+
+    $mm->init_platform
+
+Initialize any macros which are for platform specific use only.
+
+A typical one is the version number of your OS specific mocule.
+(ie. MM_Unix_VERSION or MM_VMS_VERSION).
+
+=cut
+
+sub init_platform {
+    return '';
+}
+
+
+=head3 init_MAKE
+
+    $mm->init_MAKE
+
+Initialize MAKE from either a MAKE environment variable or $Config{make}.
+
+=cut
+
+sub init_MAKE {
+    my $self = shift;
+
+    $self->{MAKE} ||= $ENV{MAKE} || $Config{make};
+}
+
+
+=head2 Tools
+
+A grab bag of methods to generate specific macros and commands.
+
+
+
+=head3 manifypods
+
+Defines targets and routines to translate the pods into manpages and
+put them into the INST_* directories.
+
+=cut
+
+sub manifypods {
+    my $self          = shift;
+
+    my $POD2MAN_macro = $self->POD2MAN_macro();
+    my $manifypods_target = $self->manifypods_target();
+
+    return <<END_OF_TARGET;
+
+$POD2MAN_macro
+
+$manifypods_target
+
+END_OF_TARGET
+
+}
+
+
+=head3 POD2MAN_macro
+
+  my $pod2man_macro = $self->POD2MAN_macro
+
+Returns a definition for the POD2MAN macro.  This is a program
+which emulates the pod2man utility.  You can add more switches to the
+command by simply appending them on the macro.
+
+Typical usage:
+
+    $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) podfile1 man_page1 ...
+
+=cut
+
+sub POD2MAN_macro {
+    my $self = shift;
+
+# Need the trailing '--' so perl stops gobbling arguments and - happens
+# to be an alternative end of line seperator on VMS so we quote it
+    return <<'END_OF_DEF';
+POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
+POD2MAN = $(POD2MAN_EXE)
+END_OF_DEF
+}
+
+
+=head3 test_via_harness
+
+  my $command = $mm->test_via_harness($perl, $tests);
+
+Returns a $command line which runs the given set of $tests with
+Test::Harness and the given $perl.
+
+Used on the t/*.t files.
+
+=cut
+
+sub test_via_harness {
+    my($self, $perl, $tests) = @_;
 
+    return qq{\t$perl "-MExtUtils::Command::MM" }.
+           qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n};
+}
+
+=head3 test_via_script
+
+  my $command = $mm->test_via_script($perl, $script);
+
+Returns a $command line which just runs a single test without
+Test::Harness.  No checks are done on the results, they're just
+printed.
+
+Used for test.pl, since they don't always follow Test::Harness
+formatting.
+
+=cut
+
+sub test_via_script {
+    my($self, $perl, $script) = @_;
+    return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n};
+}
+
+
+=head3 tool_autosplit
+
+Defines a simple perl call that runs autosplit. May be deprecated by
+pm_to_blib soon.
+
+=cut
+
+sub tool_autosplit {
+    my($self, %attribs) = @_;
+
+    my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' 
+                                  : '';
+
+    my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen);
+use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)
+PERL_CODE
+
+    return sprintf <<'MAKE_FRAG', $asplit;
+# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
+AUTOSPLITFILE = %s
+
+MAKE_FRAG
+
+}
+
+
+
+
+=head2 File::Spec wrappers
+
+ExtUtils::MM_Any is a subclass of File::Spec.  The methods noted here
+override File::Spec.
+
+
+
+=head3 catfile
+
+File::Spec <= 0.83 has a bug where the file part of catfile is not
+canonicalized.  This override fixes that bug.
+
+=cut
+
+sub catfile {
+    my $self = shift;
+    return $self->canonpath($self->SUPER::catfile(@_));
+}
+
+
+
+=head2 Misc
+
+Methods I can't really figure out where they should go yet.
+
+
+=head3 find_tests
+
+  my $test = $mm->find_tests;
+
+Returns a string suitable for feeding to the shell to return all
+tests in t/*.t.
+
+=cut
+
+sub find_tests {
+    my($self) = shift;
+    return -d 't' ? 't/*.t' : '';
+}
+
+
+=head3 extra_clean_files
+
+    my @files_to_clean = $MM->extra_clean_files;
+
+Returns a list of OS specific files to be removed in the clean target in
+addition to the usual set.
+
+=cut
+
+# An empty method here tickled a perl 5.8.1 bug and would return its object.
+sub extra_clean_files { 
+    return;
+}
+
+
+=head3 installvars
+
+    my @installvars = $mm->installvars;
+
+A list of all the INSTALL* variables without the INSTALL prefix.  Useful
+for iteration or building related variable sets.
+
+=cut
+
+sub installvars {
+    return qw(PRIVLIB SITELIB  VENDORLIB
+              ARCHLIB SITEARCH VENDORARCH
+              BIN     SITEBIN  VENDORBIN
+              SCRIPT  SITESCRIPT  VENDORSCRIPT
+              MAN1DIR SITEMAN1DIR VENDORMAN1DIR
+              MAN3DIR SITEMAN3DIR VENDORMAN3DIR
+             );
+}
+
+
+=head3 libscan
+
+  my $wanted = $self->libscan($path);
+
+Takes a path to a file or dir and returns an empty string if we don't
+want to include this file in the library.  Otherwise it returns the
+the $path unchanged.
+
+Mainly used to exclude version control administrative directories from
+installation.
+
+=cut
+
+sub libscan {
+    my($self,$path) = @_;
+    my($dirs,$file) = ($self->splitpath($path))[1,2];
+    return '' if grep /^(?:RCS|CVS|SCCS|\.svn|_darcs)$/, 
+                     $self->splitdir($dirs), $file;
+
+    return $path;
+}
+
+
+=head3 platform_constants
+
+    my $make_frag = $mm->platform_constants
+
+Returns a make fragment defining all the macros initialized in
+init_platform() rather than put them in constants().
+
+=cut
+
+sub platform_constants {
+    return '';
+}
 
-=back
 
 =head1 AUTHOR