lib/ExtUtils/MM_VMS.pm

   1 #   MM_VMS.pm
   2 #   MakeMaker default methods for VMS
   3 #   This package is inserted into @ISA of MakeMaker's MM before the
   4 #   built-in ExtUtils::MM_Unix methods if MakeMaker.pm is run under VMS.
   5 #
   6 #   Author:  Charles Bailey  bailey@newman.upenn.edu
   7
   8 package ExtUtils::MM_VMS;
   9
  10 use Carp qw( &carp );
  11 use Config;
  12 require Exporter;
  13 use VMS::Filespec;
  14 use File::Basename;
  15 use File::Spec;
  16 use vars qw($Revision @ISA);
  17 $Revision = '5.56 (27-Apr-1999)';
  18
  19 @ISA = qw( File::Spec );
  20 unshift @MM::ISA, 'ExtUtils::MM_VMS';
  21
  22 Exporter::import('ExtUtils::MakeMaker', '$Verbose', '&neatvalue');
  23
  24 =head1 NAME
  25
  26 ExtUtils::MM_VMS - methods to override UN*X behaviour in ExtUtils::MakeMaker
  27
  28 =head1 SYNOPSIS
  29
  30  use ExtUtils::MM_VMS; # Done internally by ExtUtils::MakeMaker if needed
  31
  32 =head1 DESCRIPTION
  33
  34 See ExtUtils::MM_Unix for a documentation of the methods provided
  35 there. This package overrides the implementation of these methods, not
  36 the semantics.
  37
  38 =head2 Methods always loaded
  39
  40 =over
  41
  42 =item wraplist
  43
  44 Converts a list into a string wrapped at approximately 80 columns.
  45
  46 =cut
  47
  48 sub wraplist {
  49     my($self) = shift;
  50     my($line,$hlen) = ('',0);
  51     my($word);
  52
  53     foreach $word (@_) {
  54       # Perl bug -- seems to occasionally insert extra elements when
  55       # traversing array (scalar(@array) doesn't show them, but
  56       # foreach(@array) does) (5.00307)
  57       next unless $word =~ /\w/;
  58       $line .= ' ' if length($line);
  59       if ($hlen > 80) { $line .= "\\\n\t"; $hlen = 0; }
  60       $line .= $word;
  61       $hlen += length($word) + 2;
  62     }
  63     $line;
  64 }
  65
  66 =item rootdir (override)
  67
  68 Returns a string representing of the root directory.
  69
  70 =cut
  71
  72 sub rootdir {
  73     return '';
  74 }
  75
  76 package ExtUtils::MM_VMS;
  77
  78 sub ExtUtils::MM_VMS::ext;
  79 sub ExtUtils::MM_VMS::guess_name;
  80 sub ExtUtils::MM_VMS::find_perl;
  81 sub ExtUtils::MM_VMS::path;
  82 sub ExtUtils::MM_VMS::maybe_command;
  83 sub ExtUtils::MM_VMS::maybe_command_in_dirs;
  84 sub ExtUtils::MM_VMS::perl_script;
  85 sub ExtUtils::MM_VMS::file_name_is_absolute;
  86 sub ExtUtils::MM_VMS::replace_manpage_separator;
  87 sub ExtUtils::MM_VMS::init_others;
  88 sub ExtUtils::MM_VMS::constants;
  89 sub ExtUtils::MM_VMS::cflags;
  90 sub ExtUtils::MM_VMS::const_cccmd;
  91 sub ExtUtils::MM_VMS::pm_to_blib;
  92 sub ExtUtils::MM_VMS::tool_autosplit;
  93 sub ExtUtils::MM_VMS::tool_xsubpp;
  94 sub ExtUtils::MM_VMS::xsubpp_version;
  95 sub ExtUtils::MM_VMS::tools_other;
  96 sub ExtUtils::MM_VMS::dist;
  97 sub ExtUtils::MM_VMS::c_o;
  98 sub ExtUtils::MM_VMS::xs_c;
  99 sub ExtUtils::MM_VMS::xs_o;
 100 sub ExtUtils::MM_VMS::top_targets;
 101 sub ExtUtils::MM_VMS::dlsyms;
 102 sub ExtUtils::MM_VMS::dynamic_lib;
 103 sub ExtUtils::MM_VMS::dynamic_bs;
 104 sub ExtUtils::MM_VMS::static_lib;
 105 sub ExtUtils::MM_VMS::manifypods;
 106 sub ExtUtils::MM_VMS::processPL;
 107 sub ExtUtils::MM_VMS::installbin;
 108 sub ExtUtils::MM_VMS::subdir_x;
 109 sub ExtUtils::MM_VMS::clean;
 110 sub ExtUtils::MM_VMS::realclean;
 111 sub ExtUtils::MM_VMS::dist_basics;
 112 sub ExtUtils::MM_VMS::dist_core;
 113 sub ExtUtils::MM_VMS::dist_dir;
 114 sub ExtUtils::MM_VMS::dist_test;
 115 sub ExtUtils::MM_VMS::install;
 116 sub ExtUtils::MM_VMS::perldepend;
 117 sub ExtUtils::MM_VMS::makefile;
 118 sub ExtUtils::MM_VMS::test;
 119 sub ExtUtils::MM_VMS::test_via_harness;
 120 sub ExtUtils::MM_VMS::test_via_script;
 121 sub ExtUtils::MM_VMS::makeaperl;
 122 sub ExtUtils::MM_VMS::ext;
 123 sub ExtUtils::MM_VMS::nicetext;
 124
 125 #use SelfLoader;
 126 sub AUTOLOAD {
 127     my $code;
 128     if (defined fileno(DATA)) {
 129         my $fh = select DATA;
 130         my $o = $/;                     # For future reads from the file.
 131         $/ = "\n__END__\n";
 132         $code = <DATA>;
 133         $/ = $o;
 134         select $fh;
 135         close DATA;
 136         eval $code;
 137         if ($@) {
 138             $@ =~ s/ at .*\n//;
 139             Carp::croak $@;
 140         }
 141     } else {
 142         warn "AUTOLOAD called unexpectedly for $AUTOLOAD";
 143     }
 144     defined(&$AUTOLOAD) or die "Myloader inconsistency error";
 145     goto &$AUTOLOAD;
 146 }
 147
 148 1;
 149
 150 #__DATA__
 151
 152
 153 # This isn't really an override.  It's just here because ExtUtils::MM_VMS
 154 # appears in @MM::ISA before ExtUtils::Liblist, so if there isn't an ext()
 155 # in MM_VMS, then AUTOLOAD is called, and bad things happen.  So, we just
 156 # mimic inheritance here and hand off to ExtUtils::Liblist.
 157 sub ext {
 158   ExtUtils::Liblist::ext(@_);
 159 }
 160
 161 =back
 162
 163 =head2 SelfLoaded methods
 164
 165 Those methods which override default MM_Unix methods are marked
 166 "(override)", while methods unique to MM_VMS are marked "(specific)".
 167 For overridden methods, documentation is limited to an explanation
 168 of why this method overrides the MM_Unix method; see the ExtUtils::MM_Unix
 169 documentation for more details.
 170
 171 =over
 172
 173 =item guess_name (override)
 174
 175 Try to determine name of extension being built.  We begin with the name
 176 of the current directory.  Since VMS filenames are case-insensitive,
 177 however, we look for a F<.pm> file whose name matches that of the current
 178 directory (presumably the 'main' F<.pm> file for this extension), and try
 179 to find a C<package> statement from which to obtain the Mixed::Case
 180 package name.
 181
 182 =cut
 183
 184 sub guess_name {
 185     my($self) = @_;
 186     my($defname,$defpm,@pm,%xs,$pm);
 187     local *PM;
 188
 189     $defname = basename(fileify($ENV{'DEFAULT'}));
 190     $defname =~ s![\d\-_]*\.dir.*$!!;  # Clip off .dir;1 suffix, and package version
 191     $defpm = $defname;
 192     # Fallback in case for some reason a user has copied the files for an
 193     # extension into a working directory whose name doesn't reflect the
 194     # extension's name.  We'll use the name of a unique .pm file, or the
 195     # first .pm file with a matching .xs file.
 196     if (not -e "${defpm}.pm") {
 197       @pm = map { s/.pm$//; $_ } glob('*.pm');
 198       if (@pm == 1) { ($defpm = $pm[0]) =~ s/.pm$//; }
 199       elsif (@pm) {
 200         %xs = map { s/.xs$//; ($_,1) } glob('*.xs');
 201         if (%xs) { foreach $pm (@pm) { $defpm = $pm, last if exists $xs{$pm}; } }
 202       }
 203     }
 204     if (open(PM,"${defpm}.pm")){
 205         while (<PM>) {
 206             if (/^\s*package\s+([^;]+)/i) {
 207                 $defname = $1;
 208                 last;
 209             }
 210         }
 211         print STDOUT "Warning (non-fatal): Couldn't find package name in ${defpm}.pm;\n\t",
 212                      "defaulting package name to $defname\n"
 213             if eof(PM);
 214         close PM;
 215     }
 216     else {
 217         print STDOUT "Warning (non-fatal): Couldn't find ${defpm}.pm;\n\t",
 218                      "defaulting package name to $defname\n";
 219     }
 220     $defname =~ s#[\d.\-_]+$##;
 221     $defname;
 222 }
 223
 224 =item find_perl (override)
 225
 226 Use VMS file specification syntax and CLI commands to find and
 227 invoke Perl images.
 228
 229 =cut
 230
 231 sub find_perl {
 232     my($self, $ver, $names, $dirs, $trace) = @_;
 233     my($name,$dir,$vmsfile,@sdirs,@snames,@cand);
 234     my($inabs) = 0;
 235     # Check in relative directories first, so we pick up the current
 236     # version of Perl if we're running MakeMaker as part of the main build.
 237     @sdirs = sort { my($absa) = $self->file_name_is_absolute($a);
 238                     my($absb) = $self->file_name_is_absolute($b);
 239                     if ($absa && $absb) { return $a cmp $b }
 240                     else { return $absa ? 1 : ($absb ? -1 : ($a cmp $b)); }
 241                   } @$dirs;
 242     # Check miniperl before perl, and check names likely to contain
 243     # version numbers before "generic" names, so we pick up an
 244     # executable that's less likely to be from an old installation.
 245     @snames = sort { my($ba) = $a =~ m!([^:>\]/]+)$!;  # basename
 246                      my($bb) = $b =~ m!([^:>\]/]+)$!;
 247                      my($ahasdir) = (length($a) - length($ba) > 0);
 248                      my($bhasdir) = (length($b) - length($bb) > 0);
 249                      if    ($ahasdir and not $bhasdir) { return 1; }
 250                      elsif ($bhasdir and not $ahasdir) { return -1; }
 251                      else { $bb =~ /\d/ <=> $ba =~ /\d/
 252                             or substr($ba,0,1) cmp substr($bb,0,1)
 253                             or length($bb) <=> length($ba) } } @$names;
 254     # Image names containing Perl version use '_' instead of '.' under VMS
 255     foreach $name (@snames) { $name =~ s/\.(\d+)$/_$1/; }
 256     if ($trace >= 2){
 257         print "Looking for perl $ver by these names:\n";
 258         print "\t@snames,\n";
 259         print "in these dirs:\n";
 260         print "\t@sdirs\n";
 261     }
 262     foreach $dir (@sdirs){
 263         next unless defined $dir; # $self->{PERL_SRC} may be undefined
 264         $inabs++ if $self->file_name_is_absolute($dir);
 265         if ($inabs == 1) {
 266             # We've covered relative dirs; everything else is an absolute
 267             # dir (probably an installed location).  First, we'll try potential
 268             # command names, to see whether we can avoid a long MCR expression.
 269             foreach $name (@snames) { push(@cand,$name) if $name =~ /^[\w\-\$]+$/; }
 270             $inabs++; # Should happen above in next $dir, but just in case . . .
 271         }
 272         foreach $name (@snames){
 273             if ($name !~ m![/:>\]]!) { push(@cand,$self->catfile($dir,$name)); }
 274             else                     { push(@cand,$self->fixpath($name,0));    }
 275         }
 276     }
 277     foreach $name (@cand) {
 278         print "Checking $name\n" if ($trace >= 2);
 279         # If it looks like a potential command, try it without the MCR
 280         if ($name =~ /^[\w\-\$]+$/ &&
 281             `$name -e "require $ver; print ""VER_OK\n"""` =~ /VER_OK/) {
 282             print "Using PERL=$name\n" if $trace;
 283             return $name;
 284         }
 285         next unless $vmsfile = $self->maybe_command($name);
 286         $vmsfile =~ s/;[\d\-]*$//;  # Clip off version number; we can use a newer version as well
 287         print "Executing $vmsfile\n" if ($trace >= 2);
 288         if (`MCR $vmsfile -e "require $ver; print ""VER_OK\n"""` =~ /VER_OK/) {
 289             print "Using PERL=MCR $vmsfile\n" if $trace;
 290             return "MCR $vmsfile";
 291         }
 292     }
 293     print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
 294     0; # false and not empty
 295 }
 296
 297 =item path (override)
 298
 299 Translate logical name DCL$PATH as a searchlist, rather than trying
 300 to C<split> string value of C<$ENV{'PATH'}>.
 301
 302 =cut
 303
 304 sub path {
 305     my(@dirs,$dir,$i);
 306     while ($dir = $ENV{'DCL$PATH;' . $i++}) { push(@dirs,$dir); }
 307     @dirs;
 308 }
 309
 310 =item maybe_command (override)
 311
 312 Follows VMS naming conventions for executable files.
 313 If the name passed in doesn't exactly match an executable file,
 314 appends F<.Exe> (or equivalent) to check for executable image, and F<.Com>
 315 to check for DCL procedure.  If this fails, checks directories in DCL$PATH
 316 and finally F<Sys$System:> for an executable file having the name specified,
 317 with or without the F<.Exe>-equivalent suffix.
 318
 319 =cut
 320
 321 sub maybe_command {
 322     my($self,$file) = @_;
 323     return $file if -x $file && ! -d _;
 324     my(@dirs) = ('');
 325     my(@exts) = ('',$Config{'exe_ext'},'.exe','.com');
 326     my($dir,$ext);
 327     if ($file !~ m![/:>\]]!) {
 328         for (my $i = 0; defined $ENV{"DCL\$PATH;$i"}; $i++) {
 329             $dir = $ENV{"DCL\$PATH;$i"};
 330             $dir .= ':' unless $dir =~ m%[\]:]$%;
 331             push(@dirs,$dir);
 332         }
 333         push(@dirs,'Sys$System:');
 334         foreach $dir (@dirs) {
 335             my $sysfile = "$dir$file";
 336             foreach $ext (@exts) {
 337                 return $file if -x "$sysfile$ext" && ! -d _;
 338             }
 339         }
 340     }
 341     return 0;
 342 }
 343
 344 =item maybe_command_in_dirs (override)
 345
 346 Uses DCL argument quoting on test command line.
 347
 348 =cut
 349
 350 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
 351     my($self, $names, $dirs, $trace, $ver) = @_;
 352     my($name, $dir);
 353     foreach $dir (@$dirs){
 354         next unless defined $dir; # $self->{PERL_SRC} may be undefined
 355         foreach $name (@$names){
 356             my($abs,$tryabs);
 357             if ($self->file_name_is_absolute($name)) {
 358                 $abs = $name;
 359             } else {
 360                 $abs = $self->catfile($dir, $name);
 361             }
 362             print "Checking $abs for $name\n" if ($trace >= 2);
 363             next unless $tryabs = $self->maybe_command($abs);
 364             print "Substituting $tryabs instead of $abs\n"
 365                 if ($trace >= 2 and $tryabs ne $abs);
 366             $abs = $tryabs;
 367             if (defined $ver) {
 368                 print "Executing $abs\n" if ($trace >= 2);
 369                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
 370                     print "Using $abs\n" if $trace;
 371                     return $abs;
 372                 }
 373             } else { # Do not look for perl
 374                 return $abs;
 375             }
 376         }
 377     }
 378 }
 379
 380 =item perl_script (override)
 381
 382 If name passed in doesn't specify a readable file, appends F<.com> or
 383 F<.pl> and tries again, since it's customary to have file types on all files
 384 under VMS.
 385
 386 =cut
 387
 388 sub perl_script {
 389     my($self,$file) = @_;
 390     return $file if -r $file && ! -d _;
 391     return "$file.com" if -r "$file.com";
 392     return "$file.pl" if -r "$file.pl";
 393     return '';
 394 }
 395
 396 =item file_name_is_absolute (override)
 397
 398 Checks for VMS directory spec as well as Unix separators.
 399
 400 =cut
 401
 402 sub file_name_is_absolute {
 403     my($self,$file) = @_;
 404     # If it's a logical name, expand it.
 405     $file = $ENV{$file} while $file =~ /^[\w\$\-]+$/ and $ENV{$file};
 406     $file =~ m!^/! or $file =~ m![<\[][^.\-\]>]! or $file =~ /:[^<\[]/;
 407 }
 408
 409 =item replace_manpage_separator
 410
 411 Use as separator a character which is legal in a VMS-syntax file name.
 412
 413 =cut
 414
 415 sub replace_manpage_separator {
 416     my($self,$man) = @_;
 417     $man = unixify($man);
 418     $man =~ s#/+#__#g;
 419     $man;
 420 }
 421
 422 =item init_others (override)
 423
 424 Provide VMS-specific forms of various utility commands, then hand
 425 off to the default MM_Unix method.
 426
 427 =cut
 428
 429 sub init_others {
 430     my($self) = @_;
 431
 432     $self->{NOOP} = 'Continue';
 433     $self->{FIRST_MAKEFILE} ||= 'Descrip.MMS';
 434     $self->{MAKE_APERL_FILE} ||= 'Makeaperl.MMS';
 435     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
 436     $self->{NOECHO} ||= '@ ';
 437     $self->{RM_F} = '$(PERL) -e "foreach (@ARGV) { 1 while ( -d $_ ? rmdir $_ : unlink $_)}"';
 438     $self->{RM_RF} = '$(PERL) "-I$(PERL_LIB)" -e "use File::Path; @dirs = map(VMS::Filespec::unixify($_),@ARGV); rmtree(\@dirs,0,0)"';
 439     $self->{TOUCH} = '$(PERL) -e "$t=time; foreach (@ARGV) { -e $_ ? utime($t,$t,@ARGV) : (open(F,qq(>$_)),close F)}"';
 440     $self->{CHMOD} = '$(PERL) -e "chmod @ARGV"';  # expect Unix syntax from MakeMaker
 441     $self->{CP} = 'Copy/NoConfirm';
 442     $self->{MV} = 'Rename/NoConfirm';
 443     $self->{UMASK_NULL} = '! ';
 444     &ExtUtils::MM_Unix::init_others;
 445 }
 446
 447 =item constants (override)
 448
 449 Fixes up numerous file and directory macros to insure VMS syntax
 450 regardless of input syntax.  Also adds a few VMS-specific macros
 451 and makes lists of files comma-separated.
 452
 453 =cut
 454
 455 sub constants {
 456     my($self) = @_;
 457     my(@m,$def,$macro);
 458
 459     if ($self->{DEFINE} ne '') {
 460         my(@terms) = split(/\s+/,$self->{DEFINE});
 461         my(@defs,@udefs);
 462         foreach $def (@terms) {
 463             next unless $def;
 464             my $targ = \@defs;
 465             if ($def =~ s/^-([DU])//) {       # If it was a Unix-style definition
 466                 if ($1 eq 'U') { $targ = \@udefs; }
 467                 $def =~ s/='(.*)'$/=$1/;  # then remove shell-protection ''
 468                 $def =~ s/^'(.*)'$/$1/;   # from entire term or argument
 469             }
 470             if ($def =~ /=/) {
 471                 $def =~ s/"/""/g;  # Protect existing " from DCL
 472                 $def = qq["$def"]; # and quote to prevent parsing of =
 473             }
 474             push @$targ, $def;
 475         }
 476         $self->{DEFINE} = '';
 477         if (@defs)  { $self->{DEFINE}  = '/Define=(' . join(',',@defs)  . ')'; }
 478         if (@udefs) { $self->{DEFINE} .= '/Undef=('  . join(',',@udefs) . ')'; }
 479     }
 480
 481     if ($self->{OBJECT} =~ /\s/) {
 482         $self->{OBJECT} =~ s/(\\)?\n+\s+/ /g;
 483         $self->{OBJECT} = $self->wraplist(map($self->fixpath($_,0),split(/,?\s+/,$self->{OBJECT})));
 484     }
 485     $self->{LDFROM} = $self->wraplist(map($self->fixpath($_,0),split(/,?\s+/,$self->{LDFROM})));
 486
 487
 488     # Fix up directory specs
 489     $self->{ROOTEXT} = $self->{ROOTEXT} ? $self->fixpath($self->{ROOTEXT},1)
 490                                         : '[]';
 491     foreach $macro ( qw [
 492             INST_BIN INST_SCRIPT INST_LIB INST_ARCHLIB INST_EXE INSTALLPRIVLIB
 493             INSTALLARCHLIB INSTALLSCRIPT INSTALLBIN PERL_LIB PERL_ARCHLIB
 494             PERL_INC PERL_SRC FULLEXT INST_MAN1DIR INSTALLMAN1DIR
 495             INST_MAN3DIR INSTALLMAN3DIR INSTALLSITELIB INSTALLSITEARCH
 496             SITELIBEXP SITEARCHEXP ] ) {
 497         next unless defined $self->{$macro};
 498         $self->{$macro} = $self->fixpath($self->{$macro},1);
 499     }
 500     $self->{PERL_VMS} = $self->catdir($self->{PERL_SRC},q(VMS))
 501         if ($self->{PERL_SRC});
 502
 503
 504
 505     # Fix up file specs
 506     foreach $macro ( qw[LIBPERL_A FIRST_MAKEFILE MAKE_APERL_FILE MYEXTLIB] ) {
 507         next unless defined $self->{$macro};
 508         $self->{$macro} = $self->fixpath($self->{$macro},0);
 509     }
 510
 511     foreach $macro (qw/
 512               AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION VERSION_SYM XS_VERSION
 513               INST_BIN INST_EXE INST_LIB INST_ARCHLIB INST_SCRIPT PREFIX
 514               INSTALLDIRS INSTALLPRIVLIB  INSTALLARCHLIB INSTALLSITELIB
 515               INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
 516               PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
 517               FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC PERL_VMS
 518               PERL_INC PERL FULLPERL
 519               / ) {
 520         next unless defined $self->{$macro};
 521         push @m, "$macro = $self->{$macro}\n";
 522     }
 523
 524
 525     push @m, q[
 526 VERSION_MACRO = VERSION
 527 DEFINE_VERSION = "$(VERSION_MACRO)=""$(VERSION)"""
 528 XS_VERSION_MACRO = XS_VERSION
 529 XS_DEFINE_VERSION = "$(XS_VERSION_MACRO)=""$(XS_VERSION)"""
 530
 531 MAKEMAKER = ],$self->catfile($self->{PERL_LIB},'ExtUtils','MakeMaker.pm'),qq[
 532 MM_VERSION = $ExtUtils::MakeMaker::VERSION
 533 MM_REVISION = $ExtUtils::MakeMaker::Revision
 534 MM_VMS_REVISION = $ExtUtils::MM_VMS::Revision
 535
 536 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
 537 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
 538 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
 539 # DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
 540 ];
 541
 542     for $tmp (qw/
 543               FULLEXT VERSION_FROM OBJECT LDFROM
 544               / ) {
 545         next unless defined $self->{$tmp};
 546         push @m, "$tmp = ",$self->fixpath($self->{$tmp},0),"\n";
 547     }
 548
 549     for $tmp (qw/
 550               BASEEXT PARENT_NAME DLBASE INC DEFINE LINKTYPE
 551               / ) {
 552         next unless defined $self->{$tmp};
 553         push @m, "$tmp = $self->{$tmp}\n";
 554     }
 555
 556     for $tmp (qw/ XS MAN1PODS MAN3PODS PM /) {
 557         next unless defined $self->{$tmp};
 558         my(%tmp,$key);
 559         for $key (keys %{$self->{$tmp}}) {
 560             $tmp{$self->fixpath($key,0)} = $self->fixpath($self->{$tmp}{$key},0);
 561         }
 562         $self->{$tmp} = \%tmp;
 563     }
 564
 565     for $tmp (qw/ C O_FILES H /) {
 566         next unless defined $self->{$tmp};
 567         my(@tmp,$val);
 568         for $val (@{$self->{$tmp}}) {
 569             push(@tmp,$self->fixpath($val,0));
 570         }
 571         $self->{$tmp} = \@tmp;
 572     }
 573
 574     push @m,'
 575
 576 # Handy lists of source code files:
 577 XS_FILES = ',$self->wraplist(sort keys %{$self->{XS}}),'
 578 C_FILES  = ',$self->wraplist(@{$self->{C}}),'
 579 O_FILES  = ',$self->wraplist(@{$self->{O_FILES}} ),'
 580 H_FILES  = ',$self->wraplist(@{$self->{H}}),'
 581 MAN1PODS = ',$self->wraplist(sort keys %{$self->{MAN1PODS}}),'
 582 MAN3PODS = ',$self->wraplist(sort keys %{$self->{MAN3PODS}}),'
 583
 584 ';
 585
 586     for $tmp (qw/
 587               INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
 588               /) {
 589         next unless defined $self->{$tmp};
 590         push @m, "$tmp = $self->{$tmp}\n";
 591     }
 592
 593 push @m,"
 594 .SUFFIXES :
 595 .SUFFIXES : \$(OBJ_EXT) .c .cpp .cxx .xs
 596
 597 # Here is the Config.pm that we are using/depend on
 598 CONFIGDEP = \$(PERL_ARCHLIB)Config.pm, \$(PERL_INC)config.h \$(VERSION_FROM)
 599
 600 # Where to put things:
 601 INST_LIBDIR      = $self->{INST_LIBDIR}
 602 INST_ARCHLIBDIR  = $self->{INST_ARCHLIBDIR}
 603
 604 INST_AUTODIR     = $self->{INST_AUTODIR}
 605 INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR}
 606 ";
 607
 608     if ($self->has_link_code()) {
 609         push @m,'
 610 INST_STATIC = $(INST_ARCHAUTODIR)$(BASEEXT)$(LIB_EXT)
 611 INST_DYNAMIC = $(INST_ARCHAUTODIR)$(BASEEXT).$(DLEXT)
 612 INST_BOOT = $(INST_ARCHAUTODIR)$(BASEEXT).bs
 613 ';
 614     } else {
 615         my $shr = $Config{'dbgprefix'} . 'PERLSHR';
 616         push @m,'
 617 INST_STATIC =
 618 INST_DYNAMIC =
 619 INST_BOOT =
 620 EXPORT_LIST = $(BASEEXT).opt
 621 PERL_ARCHIVE = ',($ENV{$shr} ? $ENV{$shr} : "Sys\$Share:$shr.$Config{'dlext'}"),'
 622 ';
 623     }
 624
 625     $self->{TO_INST_PM} = [ sort keys %{$self->{PM}} ];
 626     $self->{PM_TO_BLIB} = [ %{$self->{PM}} ];
 627     push @m,'
 628 TO_INST_PM = ',$self->wraplist(@{$self->{TO_INST_PM}}),'
 629
 630 PM_TO_BLIB = ',$self->wraplist(@{$self->{PM_TO_BLIB}}),'
 631 ';
 632
 633     join('',@m);
 634 }
 635
 636 =item cflags (override)
 637
 638 Bypass shell script and produce qualifiers for CC directly (but warn
 639 user if a shell script for this extension exists).  Fold multiple
 640 /Defines into one, since some C compilers pay attention to only one
 641 instance of this qualifier on the command line.
 642
 643 =cut
 644
 645 sub cflags {
 646     my($self,$libperl) = @_;
 647     my($quals) = $self->{CCFLAGS} || $Config{'ccflags'};
 648     my($definestr,$undefstr,$flagoptstr) = ('','','');
 649     my($incstr) = '/Include=($(PERL_INC)';
 650     my($name,$sys,@m);
 651
 652     ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
 653     print STDOUT "Unix shell script ".$Config{"$self->{'BASEEXT'}_cflags"}.
 654          " required to modify CC command for $self->{'BASEEXT'}\n"
 655     if ($Config{$name});
 656
 657     if ($quals =~ / -[DIUOg]/) {
 658         while ($quals =~ / -([Og])(\d*)\b/) {
 659             my($type,$lvl) = ($1,$2);
 660             $quals =~ s/ -$type$lvl\b\s*//;
 661             if ($type eq 'g') { $flagoptstr = '/NoOptimize'; }
 662             else { $flagoptstr = '/Optimize' . (defined($lvl) ? "=$lvl" : ''); }
 663         }
 664         while ($quals =~ / -([DIU])(\S+)/) {
 665             my($type,$def) = ($1,$2);
 666             $quals =~ s/ -$type$def\s*//;
 667             $def =~ s/"/""/g;
 668             if    ($type eq 'D') { $definestr .= qq["$def",]; }
 669             elsif ($type eq 'I') { $incstr .= ',' . $self->fixpath($def,1); }
 670             else                 { $undefstr  .= qq["$def",]; }
 671         }
 672     }
 673     if (length $quals and $quals !~ m!/!) {
 674         warn "MM_VMS: Ignoring unrecognized CCFLAGS elements \"$quals\"\n";
 675         $quals = '';
 676     }
 677     if (length $definestr) { chop($definestr); $quals .= "/Define=($definestr)"; }
 678     if (length $undefstr)  { chop($undefstr);  $quals .= "/Undef=($undefstr)";   }
 679     # Deal with $self->{DEFINE} here since some C compilers pay attention
 680     # to only one /Define clause on command line, so we have to
 681     # conflate the ones from $Config{'ccflags'} and $self->{DEFINE}
 682     # ($self->{DEFINE} has already been VMSified in constants() above)
 683     if ($self->{DEFINE}) { $quals .= $self->{DEFINE}; }
 684     for $type (qw(Def Undef)) {
 685         my(@terms);
 686         while ($quals =~ m:/${type}i?n?e?=([^/]+):ig) {
 687                 my $term = $1;
 688                 $term =~ s:^\((.+)\)$:$1:;
 689                 push @terms, $term;
 690             }
 691         if ($type eq 'Def') {
 692             push @terms, qw[ $(DEFINE_VERSION) $(XS_DEFINE_VERSION) ];
 693         }
 694         if (@terms) {
 695             $quals =~ s:/${type}i?n?e?=[^/]+::ig;
 696             $quals .= "/${type}ine=(" . join(',',@terms) . ')';
 697         }
 698     }
 699
 700     $libperl or $libperl = $self->{LIBPERL_A} || "libperl.olb";
 701
 702     # Likewise with $self->{INC} and /Include
 703     if ($self->{'INC'}) {
 704         my(@includes) = split(/\s+/,$self->{INC});
 705         foreach (@includes) {
 706             s/^-I//;
 707             $incstr .= ','.$self->fixpath($_,1);
 708         }
 709     }
 710     $quals .= "$incstr)";
 711 #    $quals =~ s/,,/,/g; $quals =~ s/\(,/(/g;
 712     $self->{CCFLAGS} = $quals;
 713
 714     $self->{OPTIMIZE} ||= $flagoptstr || $Config{'optimize'};
 715     if ($self->{OPTIMIZE} !~ m!/!) {
 716         if    ($self->{OPTIMIZE} =~ m!\b-g\b!) { $self->{OPTIMIZE} = '/Debug/NoOptimize' }
 717         elsif ($self->{OPTIMIZE} =~ /-O(\d*)/) {
 718             $self->{OPTIMIZE} = '/Optimize' . (defined($1) ? "=$1" : '');
 719         }
 720         else {
 721             warn "MM_VMS: Can't parse OPTIMIZE \"$self->{OPTIMIZE}\"; using default\n" if length $self->{OPTIMIZE};
 722             $self->{OPTIMIZE} = '/Optimize';
 723         }
 724     }
 725
 726     return $self->{CFLAGS} = qq{
 727 CCFLAGS = $self->{CCFLAGS}
 728 OPTIMIZE = $self->{OPTIMIZE}
 729 PERLTYPE = $self->{PERLTYPE}
 730 SPLIT =
 731 LARGE =
 732 };
 733 }
 734
 735 =item const_cccmd (override)
 736
 737 Adds directives to point C preprocessor to the right place when
 738 handling #include E<lt>sys/foo.hE<gt> directives.  Also constructs CC
 739 command line a bit differently than MM_Unix method.
 740
 741 =cut
 742
 743 sub const_cccmd {
 744     my($self,$libperl) = @_;
 745     my(@m);
 746
 747     return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
 748     return '' unless $self->needs_linking();
 749     if ($Config{'vms_cc_type'} eq 'gcc') {
 750         push @m,'
 751 .FIRST
 752         ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" Then Define/NoLog SYS GNU_CC_Include:[VMS]';
 753     }
 754     elsif ($Config{'vms_cc_type'} eq 'vaxc') {
 755         push @m,'
 756 .FIRST
 757         ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("VAXC$Include").eqs."" Then Define/NoLog SYS Sys$Library
 758         ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("VAXC$Include").nes."" Then Define/NoLog SYS VAXC$Include';
 759     }
 760     else {
 761         push @m,'
 762 .FIRST
 763         ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("DECC$System_Include").eqs."" Then Define/NoLog SYS ',
 764                 ($Config{'arch'} eq 'VMS_AXP' ? 'Sys$Library' : 'DECC$Library_Include'),'
 765         ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("DECC$System_Include").nes."" Then Define/NoLog SYS DECC$System_Include';
 766     }
 767
 768     push(@m, "\n\nCCCMD = $Config{'cc'} \$(CCFLAGS)\$(OPTIMIZE)\n");
 769
 770     $self->{CONST_CCCMD} = join('',@m);
 771 }
 772
 773 =item pm_to_blib (override)
 774
 775 DCL I<still> accepts a maximum of 255 characters on a command
 776 line, so we write the (potentially) long list of file names
 777 to a temp file, then persuade Perl to read it instead of the
 778 command line to find args.
 779
 780 =cut
 781
 782 sub pm_to_blib {
 783     my($self) = @_;
 784     my($line,$from,$to,@m);
 785     my($autodir) = $self->catdir('$(INST_LIB)','auto');
 786     my(@files) = @{$self->{PM_TO_BLIB}};
 787
 788     push @m, q{
 789
 790 # Dummy target to match Unix target name; we use pm_to_blib.ts as
 791 # timestamp file to avoid repeated invocations under VMS
 792 pm_to_blib : pm_to_blib.ts
 793         $(NOECHO) $(NOOP)
 794
 795 # As always, keep under DCL's 255-char limit
 796 pm_to_blib.ts : $(TO_INST_PM)
 797         $(NOECHO) $(PERL) -e "print '},shift(@files),q{ },shift(@files),q{'" >.MM_tmp
 798 };
 799
 800     $line = '';  # avoid uninitialized var warning
 801     while ($from = shift(@files),$to = shift(@files)) {
 802         $line .= " $from $to";
 803         if (length($line) > 128) {
 804             push(@m,"\t\$(NOECHO) \$(PERL) -e \"print '$line'\" >>.MM_tmp\n");
 805             $line = '';
 806         }
 807     }
 808     push(@m,"\t\$(NOECHO) \$(PERL) -e \"print '$line'\" >>.MM_tmp\n") if $line;
 809
 810     push(@m,q[  $(PERL) "-I$(PERL_LIB)" "-MExtUtils::Install" -e "pm_to_blib({split(' ',<STDIN>)},'].$autodir.q[')" <.MM_tmp]);
 811     push(@m,qq[
 812         \$(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;
 813         \$(NOECHO) \$(TOUCH) pm_to_blib.ts
 814 ]);
 815
 816     join('',@m);
 817 }
 818
 819 =item tool_autosplit (override)
 820
 821 Use VMS-style quoting on command line.
 822
 823 =cut
 824
 825 sub tool_autosplit{
 826     my($self, %attribs) = @_;
 827     my($asl) = "";
 828     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
 829     q{
 830 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
 831 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use AutoSplit;}.$asl.q{ AutoSplit::autosplit($ARGV[0], $ARGV[1], 0, 1, 1) ;"
 832 };
 833 }
 834
 835 =item tool_sxubpp (override)
 836
 837 Use VMS-style quoting on xsubpp command line.
 838
 839 =cut
 840
 841 sub tool_xsubpp {
 842     my($self) = @_;
 843     return '' unless $self->needs_linking;
 844     my($xsdir) = $self->catdir($self->{PERL_LIB},'ExtUtils');
 845     # drop back to old location if xsubpp is not in new location yet
 846     $xsdir = $self->catdir($self->{PERL_SRC},'ext') unless (-f $self->catfile($xsdir,'xsubpp'));
 847     my(@tmdeps) = '$(XSUBPPDIR)typemap';
 848     if( $self->{TYPEMAPS} ){
 849         my $typemap;
 850         foreach $typemap (@{$self->{TYPEMAPS}}){
 851                 if( ! -f  $typemap ){
 852                         warn "Typemap $typemap not found.\n";
 853                 }
 854                 else{
 855                         push(@tmdeps, $self->fixpath($typemap,0));
 856                 }
 857         }
 858     }
 859     push(@tmdeps, "typemap") if -f "typemap";
 860     my(@tmargs) = map("-typemap $_", @tmdeps);
 861     if( exists $self->{XSOPT} ){
 862         unshift( @tmargs, $self->{XSOPT} );
 863     }
 864
 865     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,'xsubpp'));
 866
 867     # What are the correct thresholds for version 1 && 2 Paul?
 868     if ( $xsubpp_version > 1.923 ){
 869         $self->{XSPROTOARG} = '' unless defined $self->{XSPROTOARG};
 870     } else {
 871         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
 872             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
 873         Your version of xsubpp is $xsubpp_version and cannot handle this.
 874         Please upgrade to a more recent version of xsubpp.
 875 };
 876         } else {
 877             $self->{XSPROTOARG} = "";
 878         }
 879     }
 880
 881     "
 882 XSUBPPDIR = $xsdir
 883 XSUBPP = \$(PERL) \"-I\$(PERL_ARCHLIB)\" \"-I\$(PERL_LIB)\" \$(XSUBPPDIR)xsubpp
 884 XSPROTOARG = $self->{XSPROTOARG}
 885 XSUBPPDEPS = @tmdeps
 886 XSUBPPARGS = @tmargs
 887 ";
 888 }
 889
 890 =item xsubpp_version (override)
 891
 892 Test xsubpp exit status according to VMS rules ($sts & 1 ==E<gt> good)
 893 rather than Unix rules ($sts == 0 ==E<gt> good).
 894
 895 =cut
 896
 897 sub xsubpp_version
 898 {
 899     my($self,$xsubpp) = @_;
 900     my ($version) ;
 901     return '' unless $self->needs_linking;
 902
 903     # try to figure out the version number of the xsubpp on the system
 904
 905     # first try the -v flag, introduced in 1.921 & 2.000a2
 906
 907     my $command = "$self->{PERL} \"-I$self->{PERL_LIB}\" $xsubpp -v";
 908     print "Running: $command\n" if $Verbose;
 909     $version = `$command` ;
 910     if ($?) {
 911         use vmsish 'status';
 912         warn "Running '$command' exits with status $?";
 913     }
 914     chop $version ;
 915
 916     return $1 if $version =~ /^xsubpp version (.*)/ ;
 917
 918     # nope, then try something else
 919
 920     my $counter = '000';
 921     my ($file) = 'temp' ;
 922     $counter++ while -e "$file$counter"; # don't overwrite anything
 923     $file .= $counter;
 924
 925     local(*F);
 926     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
 927     print F <<EOM ;
 928 MODULE = fred PACKAGE = fred
 929
 930 int
 931 fred(a)
 932         int     a;
 933 EOM
 934
 935     close F ;
 936
 937     $command = "$self->{PERL} $xsubpp $file";
 938     print "Running: $command\n" if $Verbose;
 939     my $text = `$command` ;
 940     if ($?) {
 941         use vmsish 'status';
 942         warn "Running '$command' exits with status $?";
 943     }
 944     unlink $file ;
 945
 946     # gets 1.2 -> 1.92 and 2.000a1
 947     return $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
 948
 949     # it is either 1.0 or 1.1
 950     return 1.1 if $text =~ /^Warning: ignored semicolon/ ;
 951
 952     # none of the above, so 1.0
 953     return "1.0" ;
 954 }
 955
 956 =item tools_other (override)
 957
 958 Adds a few MM[SK] macros, and shortens some the installatin commands,
 959 in order to stay under DCL's 255-character limit.  Also changes
 960 EQUALIZE_TIMESTAMP to set revision date of target file to one second
 961 later than source file, since MMK interprets precisely equal revision
 962 dates for a source and target file as a sign that the target needs
 963 to be updated.
 964
 965 =cut
 966
 967 sub tools_other {
 968     my($self) = @_;
 969     qq!
 970 # Assumes \$(MMS) invokes MMS or MMK
 971 # (It is assumed in some cases later that the default makefile name
 972 # (Descrip.MMS for MM[SK]) is used.)
 973 USEMAKEFILE = /Descrip=
 974 USEMACROS = /Macro=(
 975 MACROEND = )
 976 MAKEFILE = Descrip.MMS
 977 SHELL = Posix
 978 TOUCH = $self->{TOUCH}
 979 CHMOD = $self->{CHMOD}
 980 CP = $self->{CP}
 981 MV = $self->{MV}
 982 RM_F  = $self->{RM_F}
 983 RM_RF = $self->{RM_RF}
 984 SAY = Write Sys\$Output
 985 UMASK_NULL = $self->{UMASK_NULL}
 986 NOOP = $self->{NOOP}
 987 NOECHO = $self->{NOECHO}
 988 MKPATH = Create/Directory
 989 EQUALIZE_TIMESTAMP = \$(PERL) -we "open F,qq{>\$ARGV[1]};close F;utime(0,(stat(\$ARGV[0]))[9]+1,\$ARGV[1])"
 990 !. ($self->{PARENT} ? '' :
 991 qq!WARN_IF_OLD_PACKLIST = \$(PERL) -e "if (-f \$ARGV[0]){print qq[WARNING: Old package found (\$ARGV[0]); please check for collisions\\n]}"
 992 MOD_INSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "install({split(' ',<STDIN>)},1);"
 993 DOC_INSTALL = \$(PERL) -e "\@ARGV=split(/\\|/,<STDIN>);print '=head2 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];while(\$key=shift && \$val=shift){print qq[=item *\\n\\nC<\$key: \$val>\\n\\n];}print qq[=back\\n\\n]"
 994 UNINSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "uninstall(\$ARGV[0],1,1);"
 995 !);
 996 }
 997
 998 =item dist (override)
 999
1000 Provide VMSish defaults for some values, then hand off to
1001 default MM_Unix method.
1002
1003 =cut
1004
1005 sub dist {
1006     my($self, %attribs) = @_;
1007     $attribs{VERSION}      ||= $self->{VERSION_SYM};
1008     $attribs{NAME}         ||= $self->{DISTNAME};
1009     $attribs{ZIPFLAGS}     ||= '-Vu';
1010     $attribs{COMPRESS}     ||= 'gzip';
1011     $attribs{SUFFIX}       ||= '-gz';
1012     $attribs{SHAR}         ||= 'vms_share';
1013     $attribs{DIST_DEFAULT} ||= 'zipdist';
1014
1015     # Sanitize these for use in $(DISTVNAME) filespec
1016     $attribs{VERSION} =~ s/[^\w\$]/_/g;
1017     $attribs{NAME} =~ s/[^\w\$]/_/g;
1018
1019     return ExtUtils::MM_Unix::dist($self,%attribs);
1020 }
1021
1022 =item c_o (override)
1023
1024 Use VMS syntax on command line.  In particular, $(DEFINE) and
1025 $(PERL_INC) have been pulled into $(CCCMD).  Also use MM[SK] macros.
1026
1027 =cut
1028
1029 sub c_o {
1030     my($self) = @_;
1031     return '' unless $self->needs_linking();
1032     '
1033 .c$(OBJ_EXT) :
1034         $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).c
1035
1036 .cpp$(OBJ_EXT) :
1037         $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).cpp
1038
1039 .cxx$(OBJ_EXT) :
1040         $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).cxx
1041
1042 ';
1043 }
1044
1045 =item xs_c (override)
1046
1047 Use MM[SK] macros.
1048
1049 =cut
1050
1051 sub xs_c {
1052     my($self) = @_;
1053     return '' unless $self->needs_linking();
1054     '
1055 .xs.c :
1056         $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(MMS$TARGET_NAME).xs >$(MMS$TARGET)
1057 ';
1058 }
1059
1060 =item xs_o (override)
1061
1062 Use MM[SK] macros, and VMS command line for C compiler.
1063
1064 =cut
1065
1066 sub xs_o {      # many makes are too dumb to use xs_c then c_o
1067     my($self) = @_;
1068     return '' unless $self->needs_linking();
1069     '
1070 .xs$(OBJ_EXT) :
1071         $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(MMS$TARGET_NAME).xs >$(MMS$TARGET_NAME).c
1072         $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).c
1073 ';
1074 }
1075
1076 =item top_targets (override)
1077
1078 Use VMS quoting on command line for Version_check.
1079
1080 =cut
1081
1082 sub top_targets {
1083     my($self) = shift;
1084     my(@m);
1085     push @m, '
1086 all :: pure_all manifypods
1087         $(NOECHO) $(NOOP)
1088
1089 pure_all :: config pm_to_blib subdirs linkext
1090         $(NOECHO) $(NOOP)
1091
1092 subdirs :: $(MYEXTLIB)
1093         $(NOECHO) $(NOOP)
1094
1095 config :: $(MAKEFILE) $(INST_LIBDIR).exists
1096         $(NOECHO) $(NOOP)
1097
1098 config :: $(INST_ARCHAUTODIR).exists
1099         $(NOECHO) $(NOOP)
1100
1101 config :: $(INST_AUTODIR).exists
1102         $(NOECHO) $(NOOP)
1103 ';
1104
1105     push @m, q{
1106 config :: Version_check
1107         $(NOECHO) $(NOOP)
1108
1109 } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
1110
1111
1112     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
1113     if (%{$self->{MAN1PODS}}) {
1114         push @m, q[
1115 config :: $(INST_MAN1DIR).exists
1116         $(NOECHO) $(NOOP)
1117 ];
1118         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
1119     }
1120     if (%{$self->{MAN3PODS}}) {
1121         push @m, q[
1122 config :: $(INST_MAN3DIR).exists
1123         $(NOECHO) $(NOOP)
1124 ];
1125         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
1126     }
1127
1128     push @m, '
1129 $(O_FILES) : $(H_FILES)
1130 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
1131
1132     push @m, q{
1133 help :
1134         perldoc ExtUtils::MakeMaker
1135 };
1136
1137     push @m, q{
1138 Version_check :
1139         $(NOECHO) $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -
1140         "-MExtUtils::MakeMaker=Version_check" -e "&Version_check('$(MM_VERSION)')"
1141 };
1142
1143     join('',@m);
1144 }
1145
1146 =item dlsyms (override)
1147
1148 Create VMS linker options files specifying universal symbols for this
1149 extension's shareable image, and listing other shareable images or
1150 libraries to which it should be linked.
1151
1152 =cut
1153
1154 sub dlsyms {
1155     my($self,%attribs) = @_;
1156
1157     return '' unless $self->needs_linking();
1158
1159     my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
1160     my($vars)  = $attribs{DL_VARS}  || $self->{DL_VARS}  || [];
1161     my($funclist)  = $attribs{FUNCLIST}  || $self->{FUNCLIST}  || [];
1162     my(@m);
1163
1164     unless ($self->{SKIPHASH}{'dynamic'}) {
1165         push(@m,'
1166 dynamic :: $(INST_ARCHAUTODIR)$(BASEEXT).opt
1167         $(NOECHO) $(NOOP)
1168 ');
1169     }
1170
1171     push(@m,'
1172 static :: $(INST_ARCHAUTODIR)$(BASEEXT).opt
1173         $(NOECHO) $(NOOP)
1174 ') unless $self->{SKIPHASH}{'static'};
1175
1176     push(@m,'
1177 $(INST_ARCHAUTODIR)$(BASEEXT).opt : $(BASEEXT).opt
1178         $(CP) $(MMS$SOURCE) $(MMS$TARGET)
1179
1180 $(BASEEXT).opt : Makefile.PL
1181         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Mksymlists;" -
1182         ',qq[-e "Mksymlists('NAME' => '$self->{NAME}', 'DL_FUNCS' => ],
1183         neatvalue($funcs),q[, 'DL_VARS' => ],neatvalue($vars),
1184         q[, 'FUNCLIST' => ],neatvalue($funclist),')"
1185         $(PERL) -e "print ""$(INST_STATIC)/Include=$(BASEEXT)\n$(INST_STATIC)/Library\n"";" >>$(MMS$TARGET)
1186 ');
1187
1188     if (length $self->{LDLOADLIBS}) {
1189         my($lib); my($line) = '';
1190         foreach $lib (split ' ', $self->{LDLOADLIBS}) {
1191             $lib =~ s%\$%\\\$%g;  # Escape '$' in VMS filespecs
1192             if (length($line) + length($lib) > 160) {
1193                 push @m, "\t\$(PERL) -e \"print qq{$line}\" >>\$(MMS\$TARGET)\n";
1194                 $line = $lib . '\n';
1195             }
1196             else { $line .= $lib . '\n'; }
1197         }
1198         push @m, "\t\$(PERL) -e \"print qq{$line}\" >>\$(MMS\$TARGET)\n" if $line;
1199     }
1200
1201     join('',@m);
1202
1203 }
1204
1205 =item dynamic_lib (override)
1206
1207 Use VMS Link command.
1208
1209 =cut
1210
1211 sub dynamic_lib {
1212     my($self, %attribs) = @_;
1213     return '' unless $self->needs_linking(); #might be because of a subdir
1214
1215     return '' unless $self->has_link_code();
1216
1217     my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
1218     my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
1219     my $shr = $Config{'dbgprefix'} . 'PerlShr';
1220     my(@m);
1221     push @m,"
1222
1223 OTHERLDFLAGS = $otherldflags
1224 INST_DYNAMIC_DEP = $inst_dynamic_dep
1225
1226 ";
1227     push @m, '
1228 $(INST_DYNAMIC) : $(INST_STATIC) $(PERL_INC)perlshr_attr.opt $(INST_ARCHAUTODIR).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
1229         $(NOECHO) $(MKPATH) $(INST_ARCHAUTODIR)
1230         If F$TrnLNm("',$shr,'").eqs."" Then Define/NoLog/User ',"$shr Sys\$Share:$shr.$Config{'dlext'}",'
1231         Link $(LDFLAGS) /Shareable=$(MMS$TARGET)$(OTHERLDFLAGS) $(BASEEXT).opt/Option,$(PERL_INC)perlshr_attr.opt/Option
1232 ';
1233
1234     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1235     join('',@m);
1236 }
1237
1238 =item dynamic_bs (override)
1239
1240 Use VMS-style quoting on Mkbootstrap command line.
1241
1242 =cut
1243
1244 sub dynamic_bs {
1245     my($self, %attribs) = @_;
1246     return '
1247 BOOTSTRAP =
1248 ' unless $self->has_link_code();
1249     '
1250 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
1251
1252 # As MakeMaker mkbootstrap might not write a file (if none is required)
1253 # we use touch to prevent make continually trying to remake it.
1254 # The DynaLoader only reads a non-empty file.
1255 $(BOOTSTRAP) : $(MAKEFILE) '."$self->{BOOTDEP}".' $(INST_ARCHAUTODIR).exists
1256         $(NOECHO) $(SAY) "Running mkbootstrap for $(NAME) ($(BSLOADLIBS))"
1257         $(NOECHO) $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -
1258         -e "use ExtUtils::Mkbootstrap; Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
1259         $(NOECHO) $(TOUCH) $(MMS$TARGET)
1260
1261 $(INST_BOOT) : $(BOOTSTRAP) $(INST_ARCHAUTODIR).exists
1262         $(NOECHO) $(RM_RF) $(INST_BOOT)
1263         - $(CP) $(BOOTSTRAP) $(INST_BOOT)
1264 ';
1265 }
1266
1267 =item static_lib (override)
1268
1269 Use VMS commands to manipulate object library.
1270
1271 =cut
1272
1273 sub static_lib {
1274     my($self) = @_;
1275     return '' unless $self->needs_linking();
1276
1277     return '
1278 $(INST_STATIC) :
1279         $(NOECHO) $(NOOP)
1280 ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
1281
1282     my(@m,$lib);
1283     push @m,'
1284 # Rely on suffix rule for update action
1285 $(OBJECT) : $(INST_ARCHAUTODIR).exists
1286
1287 $(INST_STATIC) : $(OBJECT) $(MYEXTLIB)
1288 ';
1289     # If this extension has it's own library (eg SDBM_File)
1290     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
1291     push(@m, "\t",'$(CP) $(MYEXTLIB) $(MMS$TARGET)',"\n") if $self->{MYEXTLIB};
1292
1293     push(@m,"\t",'If F$Search("$(MMS$TARGET)").eqs."" Then Library/Object/Create $(MMS$TARGET)',"\n");
1294
1295     # if there was a library to copy, then we can't use MMS$SOURCE_LIST,
1296     # 'cause it's a library and you can't stick them in other libraries.
1297     # In that case, we use $OBJECT instead and hope for the best
1298     if ($self->{MYEXTLIB}) {
1299       push(@m,"\t",'Library/Object/Replace $(MMS$TARGET) $(OBJECT)',"\n");
1300     } else {
1301       push(@m,"\t",'Library/Object/Replace $(MMS$TARGET) $(MMS$SOURCE_LIST)',"\n");
1302     }
1303
1304     push @m, "\t\$(NOECHO) \$(PERL) -e 1 >\$(INST_ARCHAUTODIR)extralibs.ld\n";
1305     foreach $lib (split ' ', $self->{EXTRALIBS}) {
1306       push(@m,"\t",'$(NOECHO) $(PERL) -e "print qq{',$lib,'\n}" >>$(INST_ARCHAUTODIR)extralibs.ld',"\n");
1307     }
1308     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
1309     join('',@m);
1310 }
1311
1312
1313 =item manifypods (override)
1314
1315 Use VMS-style quoting on command line, and VMS logical name
1316 to specify fallback location at build time if we can't find pod2man.
1317
1318 =cut
1319
1320
1321 sub manifypods {
1322     my($self, %attribs) = @_;
1323     return "\nmanifypods :\n\t\$(NOECHO) \$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
1324     my($dist);
1325     my($pod2man_exe);
1326     if (defined $self->{PERL_SRC}) {
1327         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
1328     } else {
1329         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
1330     }
1331     if (not ($pod2man_exe = $self->perl_script($pod2man_exe))) {
1332         # No pod2man but some MAN3PODS to be installed
1333         print <<END;
1334
1335 Warning: I could not locate your pod2man program.  As a last choice,
1336          I will look for the file to which the logical name POD2MAN
1337          points when MMK is invoked.
1338
1339 END
1340         $pod2man_exe = "pod2man";
1341     }
1342     my(@m);
1343     push @m,
1344 qq[POD2MAN_EXE = $pod2man_exe\n],
1345 q[POD2MAN = $(PERL) -we "%m=@ARGV;for (keys %m){" -
1346 -e "system(""MCR $^X $(POD2MAN_EXE) $_ >$m{$_}"");}"
1347 ];
1348     push @m, "\nmanifypods : \$(MAN1PODS) \$(MAN3PODS)\n";
1349     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
1350         my($pod);
1351         foreach $pod (sort keys %{$self->{MAN1PODS}}) {
1352             push @m, qq[\t\@- If F\$Search("\$(POD2MAN_EXE)").nes."" Then \$(POD2MAN) ];
1353             push @m, "$pod $self->{MAN1PODS}{$pod}\n";
1354         }
1355         foreach $pod (sort keys %{$self->{MAN3PODS}}) {
1356             push @m, qq[\t\@- If F\$Search("\$(POD2MAN_EXE)").nes."" Then \$(POD2MAN) ];
1357             push @m, "$pod $self->{MAN3PODS}{$pod}\n";
1358         }
1359     }
1360     join('', @m);
1361 }
1362
1363 =item processPL (override)
1364
1365 Use VMS-style quoting on command line.
1366
1367 =cut
1368
1369 sub processPL {
1370     my($self) = @_;
1371     return "" unless $self->{PL_FILES};
1372     my(@m, $plfile);
1373     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
1374         my $list = ref($self->{PL_FILES}->{$plfile})
1375                 ? $self->{PL_FILES}->{$plfile}
1376                 : [$self->{PL_FILES}->{$plfile}];
1377         foreach $target (@$list) {
1378             my $vmsplfile = vmsify($plfile);
1379             my $vmsfile = vmsify($target);
1380             push @m, "
1381 all :: $vmsfile
1382         \$(NOECHO) \$(NOOP)
1383
1384 $vmsfile :: $vmsplfile
1385 ",'     $(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" '," $vmsplfile $vmsfile
1386 ";
1387         }
1388     }
1389     join "", @m;
1390 }
1391
1392 =item installbin (override)
1393
1394 Stay under DCL's 255 character command line limit once again by
1395 splitting potentially long list of files across multiple lines
1396 in C<realclean> target.
1397
1398 =cut
1399
1400 sub installbin {
1401     my($self) = @_;
1402     return '' unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
1403     return '' unless @{$self->{EXE_FILES}};
1404     my(@m, $from, $to, %fromto, @to, $line);
1405     my(@exefiles) = map { vmsify($_) } @{$self->{EXE_FILES}};
1406     for $from (@exefiles) {
1407         my($path) = '$(INST_SCRIPT)' . basename($from);
1408         local($_) = $path;  # backward compatibility
1409         $to = $self->libscan($path);
1410         print "libscan($from) => '$to'\n" if ($Verbose >=2);
1411         $fromto{$from} = vmsify($to);
1412     }
1413     @to = values %fromto;
1414     push @m, "
1415 EXE_FILES = @exefiles
1416
1417 all :: @to
1418         \$(NOECHO) \$(NOOP)
1419
1420 realclean ::
1421 ";
1422     $line = '';  #avoid unitialized var warning
1423     foreach $to (@to) {
1424         if (length($line) + length($to) > 80) {
1425             push @m, "\t\$(RM_F) $line\n";
1426             $line = $to;
1427         }
1428         else { $line .= " $to"; }
1429     }
1430     push @m, "\t\$(RM_F) $line\n\n" if $line;
1431
1432     while (($from,$to) = each %fromto) {
1433         last unless defined $from;
1434         my $todir;
1435         if ($to =~ m#[/>:\]]#) { $todir = dirname($to); }
1436         else                   { ($todir = $to) =~ s/[^\)]+$//; }
1437         $todir = $self->fixpath($todir,1);
1438         push @m, "
1439 $to : $from \$(MAKEFILE) ${todir}.exists
1440         \$(CP) $from $to
1441
1442 ", $self->dir_target($todir);
1443     }
1444     join "", @m;
1445 }
1446
1447 =item subdir_x (override)
1448
1449 Use VMS commands to change default directory.
1450
1451 =cut
1452
1453 sub subdir_x {
1454     my($self, $subdir) = @_;
1455     my(@m,$key);
1456     $subdir = $self->fixpath($subdir,1);
1457     push @m, '
1458
1459 subdirs ::
1460         olddef = F$Environment("Default")
1461         Set Default ',$subdir,'
1462         - $(MMS)$(MMSQUALIFIERS) all $(USEMACROS)$(PASTHRU)$(MACROEND)
1463         Set Default \'olddef\'
1464 ';
1465     join('',@m);
1466 }
1467
1468 =item clean (override)
1469
1470 Split potentially long list of files across multiple commands (in
1471 order to stay under the magic command line limit).  Also use MM[SK]
1472 commands for handling subdirectories.
1473
1474 =cut
1475
1476 sub clean {
1477     my($self, %attribs) = @_;
1478     my(@m,$dir);
1479     push @m, '
1480 # Delete temporary files but do not touch installed files. We don\'t delete
1481 # the Descrip.MMS here so that a later make realclean still has it to use.
1482 clean ::
1483 ';
1484     foreach $dir (@{$self->{DIR}}) { # clean subdirectories first
1485         my($vmsdir) = $self->fixpath($dir,1);
1486         push( @m, '     If F$Search("'.$vmsdir.'$(MAKEFILE)").nes."" Then \\',"\n\t",
1487               '$(PERL) -e "chdir ',"'$vmsdir'",'; print `$(MMS)$(MMSQUALIFIERS) clean`;"',"\n");
1488     }
1489     push @m, '  $(RM_F) *.Map *.Dmp *.Lis *.cpp *.$(DLEXT) *$(OBJ_EXT) *$(LIB_EXT) *.Opt $(BOOTSTRAP) $(BASEEXT).bso .MM_Tmp
1490 ';
1491
1492     my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
1493     # Unlink realclean, $attribs{FILES} is a string here; it may contain
1494     # a list or a macro that expands to a list.
1495     if ($attribs{FILES}) {
1496         my($word,$key,@filist);
1497         if (ref $attribs{FILES} eq 'ARRAY') { @filist = @{$attribs{FILES}}; }
1498         else { @filist = split /\s+/, $attribs{FILES}; }
1499         foreach $word (@filist) {
1500             if (($key) = $word =~ m#^\$\((.*)\)$# and ref $self->{$key} eq 'ARRAY') {
1501                 push(@otherfiles, @{$self->{$key}});
1502             }
1503             else { push(@otherfiles, $word); }
1504         }
1505     }
1506     push(@otherfiles, qw[ blib $(MAKE_APERL_FILE) extralibs.ld perlmain.c pm_to_blib.ts ]);
1507     push(@otherfiles,$self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'));
1508     my($file,$line);
1509     $line = '';  #avoid unitialized var warning
1510     # Occasionally files are repeated several times from different sources
1511     { my(%of) = map { ($_,1) } @otherfiles; @otherfiles = keys %of; }
1512
1513     foreach $file (@otherfiles) {
1514         $file = $self->fixpath($file);
1515         if (length($line) + length($file) > 80) {
1516             push @m, "\t\$(RM_RF) $line\n";
1517             $line = "$file";
1518         }
1519         else { $line .= " $file"; }
1520     }
1521     push @m, "\t\$(RM_RF) $line\n" if $line;
1522     push(@m, "  $attribs{POSTOP}\n") if $attribs{POSTOP};
1523     join('', @m);
1524 }
1525
1526 =item realclean (override)
1527
1528 Guess what we're working around?  Also, use MM[SK] for subdirectories.
1529
1530 =cut
1531
1532 sub realclean {
1533     my($self, %attribs) = @_;
1534     my(@m);
1535     push(@m,'
1536 # Delete temporary files (via clean) and also delete installed files
1537 realclean :: clean
1538 ');
1539     foreach(@{$self->{DIR}}){
1540         my($vmsdir) = $self->fixpath($_,1);
1541         push(@m, '      If F$Search("'."$vmsdir".'$(MAKEFILE)").nes."" Then \\',"\n\t",
1542               '$(PERL) -e "chdir ',"'$vmsdir'",'; print `$(MMS)$(MMSQUALIFIERS) realclean`;"',"\n");
1543     }
1544     push @m,'   $(RM_RF) $(INST_AUTODIR) $(INST_ARCHAUTODIR)
1545 ';
1546     # We can't expand several of the MMS macros here, since they don't have
1547     # corresponding %$self keys (i.e. they're defined in Descrip.MMS as a
1548     # combination of macros).  In order to stay below DCL's 255 char limit,
1549     # we put only 2 on a line.
1550     my($file,$line,$fcnt);
1551     my(@files) = qw{ $(MAKEFILE) $(MAKEFILE)_old };
1552     if ($self->has_link_code) {
1553         push(@files,qw{ $(INST_DYNAMIC) $(INST_STATIC) $(INST_BOOT) $(OBJECT) });
1554     }
1555     push(@files, values %{$self->{PM}});
1556     $line = '';  #avoid unitialized var warning
1557     # Occasionally files are repeated several times from different sources
1558     { my(%f) = map { ($_,1) } @files; @files = keys %f; }
1559     foreach $file (@files) {
1560         $file = $self->fixpath($file);
1561         if (length($line) + length($file) > 80 || ++$fcnt >= 2) {
1562             push @m, "\t\$(RM_F) $line\n";
1563             $line = "$file";
1564             $fcnt = 0;
1565         }
1566         else { $line .= " $file"; }
1567     }
1568     push @m, "\t\$(RM_F) $line\n" if $line;
1569     if ($attribs{FILES}) {
1570         my($word,$key,@filist,@allfiles);
1571         if (ref $attribs{FILES} eq 'ARRAY') { @filist = @{$attribs{FILES}}; }
1572         else { @filist = split /\s+/, $attribs{FILES}; }
1573         foreach $word (@filist) {
1574             if (($key) = $word =~ m#^\$\((.*)\)$# and ref $self->{$key} eq 'ARRAY') {
1575                 push(@allfiles, @{$self->{$key}});
1576             }
1577             else { push(@allfiles, $word); }
1578         }
1579         $line = '';
1580         # Occasionally files are repeated several times from different sources
1581         { my(%af) = map { ($_,1) } @allfiles; @allfiles = keys %af; }
1582         foreach $file (@allfiles) {
1583             $file = $self->fixpath($file);
1584             if (length($line) + length($file) > 80) {
1585                 push @m, "\t\$(RM_RF) $line\n";
1586                 $line = "$file";
1587             }
1588             else { $line .= " $file"; }
1589         }
1590         push @m, "\t\$(RM_RF) $line\n" if $line;
1591     }
1592     push(@m, "  $attribs{POSTOP}\n")                     if $attribs{POSTOP};
1593     join('', @m);
1594 }
1595
1596 =item dist_basics (override)
1597
1598 Use VMS-style quoting on command line.
1599
1600 =cut
1601
1602 sub dist_basics {
1603     my($self) = @_;
1604 '
1605 distclean :: realclean distcheck
1606         $(NOECHO) $(NOOP)
1607
1608 distcheck :
1609         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&fullcheck\'; fullcheck()"
1610
1611 skipcheck :
1612         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&skipcheck\'; skipcheck()"
1613
1614 manifest :
1615         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&mkmanifest\'; mkmanifest()"
1616 ';
1617 }
1618
1619 =item dist_core (override)
1620
1621 Syntax for invoking F<VMS_Share> differs from that for Unix F<shar>,
1622 so C<shdist> target actions are VMS-specific.
1623
1624 =cut
1625
1626 sub dist_core {
1627     my($self) = @_;
1628 q[
1629 dist : $(DIST_DEFAULT)
1630         $(NOECHO) $(PERL) -le "print 'Warning: $m older than $vf' if -e ($vf = '$(VERSION_FROM)') && -M $vf < -M ($m = '$(MAKEFILE)')"
1631
1632 zipdist : $(DISTVNAME).zip
1633         $(NOECHO) $(NOOP)
1634
1635 $(DISTVNAME).zip : distdir
1636         $(PREOP)
1637         $(ZIP) "$(ZIPFLAGS)" $(MMS$TARGET) [.$(DISTVNAME)...]*.*;
1638         $(RM_RF) $(DISTVNAME)
1639         $(POSTOP)
1640
1641 $(DISTVNAME).tar$(SUFFIX) : distdir
1642         $(PREOP)
1643         $(TO_UNIX)
1644         $(TAR) "$(TARFLAGS)" $(DISTVNAME).tar [.$(DISTVNAME)]
1645         $(RM_RF) $(DISTVNAME)
1646         $(COMPRESS) $(DISTVNAME).tar
1647         $(POSTOP)
1648
1649 shdist : distdir
1650         $(PREOP)
1651         $(SHAR) [.$(DISTVNAME...]*.*; $(DISTVNAME).share
1652         $(RM_RF) $(DISTVNAME)
1653         $(POSTOP)
1654 ];
1655 }
1656
1657 =item dist_dir (override)
1658
1659 Use VMS-style quoting on command line.
1660
1661 =cut
1662
1663 sub dist_dir {
1664     my($self) = @_;
1665 q{
1666 distdir :
1667         $(RM_RF) $(DISTVNAME)
1668         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest '/mani/';" \\
1669         -e "manicopy(maniread(),'$(DISTVNAME)','$(DIST_CP)');"
1670 };
1671 }
1672
1673 =item dist_test (override)
1674
1675 Use VMS commands to change default directory, and use VMS-style
1676 quoting on command line.
1677
1678 =cut
1679
1680 sub dist_test {
1681     my($self) = @_;
1682 q{
1683 disttest : distdir
1684         startdir = F$Environment("Default")
1685         Set Default [.$(DISTVNAME)]
1686         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL
1687         $(MMS)$(MMSQUALIFIERS)
1688         $(MMS)$(MMSQUALIFIERS) test
1689         Set Default 'startdir'
1690 };
1691 }
1692
1693 # --- Test and Installation Sections ---
1694
1695 =item install (override)
1696
1697 Work around DCL's 255 character limit several times,and use
1698 VMS-style command line quoting in a few cases.
1699
1700 =cut
1701
1702 sub install {
1703     my($self, %attribs) = @_;
1704     my(@m,@docfiles);
1705
1706     if ($self->{EXE_FILES}) {
1707         my($line,$file) = ('','');
1708         foreach $file (@{$self->{EXE_FILES}}) {
1709             $line .= "$file ";
1710             if (length($line) > 128) {
1711                 push(@docfiles,qq[\t\$(PERL) -e "print '$line'" >>.MM_tmp\n]);
1712                 $line = '';
1713             }
1714         }
1715         push(@docfiles,qq[\t\$(PERL) -e "print '$line'" >>.MM_tmp\n]) if $line;
1716     }
1717
1718     push @m, q[
1719 install :: all pure_install doc_install
1720         $(NOECHO) $(NOOP)
1721
1722 install_perl :: all pure_perl_install doc_perl_install
1723         $(NOECHO) $(NOOP)
1724
1725 install_site :: all pure_site_install doc_site_install
1726         $(NOECHO) $(NOOP)
1727
1728 install_ :: install_site
1729         $(NOECHO) $(SAY) "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
1730
1731 pure_install :: pure_$(INSTALLDIRS)_install
1732         $(NOECHO) $(NOOP)
1733
1734 doc_install :: doc_$(INSTALLDIRS)_install
1735         $(NOECHO) $(SAY) "Appending installation info to $(INSTALLARCHLIB)perllocal.pod"
1736
1737 pure__install : pure_site_install
1738         $(NOECHO) $(SAY) "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
1739
1740 doc__install : doc_site_install
1741         $(NOECHO) $(SAY) "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
1742
1743 # This hack brought to you by DCL's 255-character command line limit
1744 pure_perl_install ::
1745         $(NOECHO) $(PERL) -e "print 'read ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[ '" >.MM_tmp
1746         $(NOECHO) $(PERL) -e "print 'write ].$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
1747         $(NOECHO) $(PERL) -e "print '$(INST_LIB) $(INSTALLPRIVLIB) '" >>.MM_tmp
1748         $(NOECHO) $(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLARCHLIB) '" >>.MM_tmp
1749         $(NOECHO) $(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
1750         $(NOECHO) $(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
1751         $(NOECHO) $(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
1752         $(NOECHO) $(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
1753         $(MOD_INSTALL) <.MM_tmp
1754         $(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;
1755         $(NOECHO) $(WARN_IF_OLD_PACKLIST) ].$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q[
1756
1757 # Likewise
1758 pure_site_install ::
1759         $(NOECHO) $(PERL) -e "print 'read ].$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q[ '" >.MM_tmp
1760         $(NOECHO) $(PERL) -e "print 'write ].$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
1761         $(NOECHO) $(PERL) -e "print '$(INST_LIB) $(INSTALLSITELIB) '" >>.MM_tmp
1762         $(NOECHO) $(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLSITEARCH) '" >>.MM_tmp
1763         $(NOECHO) $(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
1764         $(NOECHO) $(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
1765         $(NOECHO) $(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
1766         $(NOECHO) $(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
1767         $(MOD_INSTALL) <.MM_tmp
1768         $(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;
1769         $(NOECHO) $(WARN_IF_OLD_PACKLIST) ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[
1770
1771 # Ditto
1772 doc_perl_install ::
1773         $(NOECHO) $(PERL) -e "print 'Module $(NAME)|installed into|$(INSTALLPRIVLIB)|'" >.MM_tmp
1774         $(NOECHO) $(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|EXE_FILES|$(EXE_FILES)|'" >>.MM_tmp
1775 ],@docfiles,
1776 q%      $(NOECHO) $(PERL) -e "print q[@ARGV=split(/\\|/,<STDIN>);]" >.MM2_tmp
1777         $(NOECHO) $(PERL) -e "print q[print '=head2 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];]" >>.MM2_tmp
1778         $(NOECHO) $(PERL) -e "print q[while(($key=shift) && ($val=shift)) ]" >>.MM2_tmp
1779         $(NOECHO) $(PERL) -e "print q[{print qq[=item *\\n\\nC<$key: $val>\\n\\n];}print qq[=back\\n\\n];]" >>.MM2_tmp
1780         $(NOECHO) $(PERL) .MM2_tmp <.MM_tmp >>%.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
1781         $(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;,.MM2_tmp;
1782
1783 # And again
1784 doc_site_install ::
1785         $(NOECHO) $(PERL) -e "print 'Module $(NAME)|installed into|$(INSTALLSITELIB)|'" >.MM_tmp
1786         $(NOECHO) $(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|EXE_FILES|$(EXE_FILES)|'" >>.MM_tmp
1787 ],@docfiles,
1788 q%      $(NOECHO) $(PERL) -e "print q[@ARGV=split(/\\|/,<STDIN>);]" >.MM2_tmp
1789         $(NOECHO) $(PERL) -e "print q[print '=head2 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];]" >>.MM2_tmp
1790         $(NOECHO) $(PERL) -e "print q[while(($key=shift) && ($val=shift)) ]" >>.MM2_tmp
1791         $(NOECHO) $(PERL) -e "print q[{print qq[=item *\\n\\nC<$key: $val>\\n\\n];}print qq[=back\\n\\n];]" >>.MM2_tmp
1792         $(NOECHO) $(PERL) .MM2_tmp <.MM_tmp >>%.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
1793         $(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;,.MM2_tmp;
1794
1795 ];
1796
1797     push @m, q[
1798 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
1799         $(NOECHO) $(NOOP)
1800
1801 uninstall_from_perldirs ::
1802         $(NOECHO) $(UNINSTALL) ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[
1803         $(NOECHO) $(SAY) "Uninstall is now deprecated and makes no actual changes."
1804         $(NOECHO) $(SAY) "Please check the list above carefully for errors, and manually remove"
1805         $(NOECHO) $(SAY) "the appropriate files.  Sorry for the inconvenience."
1806
1807 uninstall_from_sitedirs ::
1808         $(NOECHO) $(UNINSTALL) ],$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist'),"\n",q[
1809         $(NOECHO) $(SAY) "Uninstall is now deprecated and makes no actual changes."
1810         $(NOECHO) $(SAY) "Please check the list above carefully for errors, and manually remove"
1811         $(NOECHO) $(SAY) "the appropriate files.  Sorry for the inconvenience."
1812 ];
1813
1814     join('',@m);
1815 }
1816
1817 =item perldepend (override)
1818
1819 Use VMS-style syntax for files; it's cheaper to just do it directly here
1820 than to have the MM_Unix method call C<catfile> repeatedly.  Also, if
1821 we have to rebuild Config.pm, use MM[SK] to do it.
1822
1823 =cut
1824
1825 sub perldepend {
1826     my($self) = @_;
1827     my(@m);
1828
1829     push @m, '
1830 $(OBJECT) : $(PERL_INC)EXTERN.h, $(PERL_INC)INTERN.h, $(PERL_INC)XSUB.h, $(PERL_INC)av.h
1831 $(OBJECT) : $(PERL_INC)cop.h, $(PERL_INC)cv.h, $(PERL_INC)embed.h, $(PERL_INC)form.h
1832 $(OBJECT) : $(PERL_INC)gv.h, $(PERL_INC)handy.h, $(PERL_INC)hv.h, $(PERL_INC)keywords.h
1833 $(OBJECT) : $(PERL_INC)mg.h, $(PERL_INC)op.h, $(PERL_INC)opcode.h, $(PERL_INC)patchlevel.h
1834 $(OBJECT) : $(PERL_INC)perl.h, $(PERL_INC)perly.h, $(PERL_INC)pp.h, $(PERL_INC)proto.h
1835 $(OBJECT) : $(PERL_INC)regcomp.h, $(PERL_INC)regexp.h, $(PERL_INC)scope.h, $(PERL_INC)sv.h
1836 $(OBJECT) : $(PERL_INC)vmsish.h, $(PERL_INC)util.h, $(PERL_INC)config.h
1837 $(OBJECT) : $(PERL_INC)iperlsys.h
1838
1839 ' if $self->{OBJECT};
1840
1841     if ($self->{PERL_SRC}) {
1842         my(@macros);
1843         my($mmsquals) = '$(USEMAKEFILE)[.vms]$(MAKEFILE)';
1844         push(@macros,'__AXP__=1') if $Config{'arch'} eq 'VMS_AXP';
1845         push(@macros,'DECC=1')    if $Config{'vms_cc_type'} eq 'decc';
1846         push(@macros,'GNUC=1')    if $Config{'vms_cc_type'} eq 'gcc';
1847         push(@macros,'SOCKET=1')  if $Config{'d_has_sockets'};
1848         push(@macros,qq["CC=$Config{'cc'}"])  if $Config{'cc'} =~ m!/!;
1849         $mmsquals .= '$(USEMACROS)' . join(',',@macros) . '$(MACROEND)' if @macros;
1850         push(@m,q[
1851 # Check for unpropagated config.sh changes. Should never happen.
1852 # We do NOT just update config.h because that is not sufficient.
1853 # An out of date config.h is not fatal but complains loudly!
1854 $(PERL_INC)config.h : $(PERL_SRC)config.sh
1855
1856 $(PERL_ARCHLIB)Config.pm : $(PERL_SRC)config.sh
1857         $(NOECHO) Write Sys$Error "$(PERL_ARCHLIB)Config.pm may be out of date with config.h or genconfig.pl"
1858         olddef = F$Environment("Default")
1859         Set Default $(PERL_SRC)
1860         $(MMS)],$mmsquals,);
1861         if ($self->{PERL_ARCHLIB} =~ m|\[-| && $self->{PERL_SRC} =~ m|(\[-+)|) {
1862             my($prefix,$target) = ($1,$self->fixpath('$(PERL_ARCHLIB)Config.pm',0));
1863             $target =~ s/\Q$prefix/[/;
1864             push(@m," $target");
1865         }
1866         else { push(@m,' $(MMS$TARGET)'); }
1867         push(@m,q[
1868         Set Default 'olddef'
1869 ]);
1870     }
1871
1872     push(@m, join(" ", map($self->fixpath($_,0),values %{$self->{XS}}))." : \$(XSUBPPDEPS)\n")
1873       if %{$self->{XS}};
1874
1875     join('',@m);
1876 }
1877
1878 =item makefile (override)
1879
1880 Use VMS commands and quoting.
1881
1882 =cut
1883
1884 sub makefile {
1885     my($self) = @_;
1886     my(@m,@cmd);
1887     # We do not know what target was originally specified so we
1888     # must force a manual rerun to be sure. But as it should only
1889     # happen very rarely it is not a significant problem.
1890     push @m, q[
1891 $(OBJECT) : $(FIRST_MAKEFILE)
1892 ] if $self->{OBJECT};
1893
1894     push @m,q[
1895 # We take a very conservative approach here, but it\'s worth it.
1896 # We move $(MAKEFILE) to $(MAKEFILE)_old here to avoid gnu make looping.
1897 $(MAKEFILE) : Makefile.PL $(CONFIGDEP)
1898         $(NOECHO) $(SAY) "$(MAKEFILE) out-of-date with respect to $(MMS$SOURCE_LIST)"
1899         $(NOECHO) $(SAY) "Cleaning current config before rebuilding $(MAKEFILE) ..."
1900         - $(MV) $(MAKEFILE) $(MAKEFILE)_old
1901         - $(MMS)$(MMSQUALIFIERS) $(USEMAKEFILE)$(MAKEFILE)_old clean
1902         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL ],join(' ',map(qq["$_"],@ARGV)),q[
1903         $(NOECHO) $(SAY) "$(MAKEFILE) has been rebuilt."
1904         $(NOECHO) $(SAY) "Please run $(MMS) to build the extension."
1905 ];
1906
1907     join('',@m);
1908 }
1909
1910 =item test (override)
1911
1912 Use VMS commands for handling subdirectories.
1913
1914 =cut
1915
1916 sub test {
1917     my($self, %attribs) = @_;
1918     my($tests) = $attribs{TESTS} || ( -d 't' ? 't/*.t' : '');
1919     my(@m);
1920     push @m,"
1921 TEST_VERBOSE = 0
1922 TEST_TYPE = test_\$(LINKTYPE)
1923 TEST_FILE = test.pl
1924 TESTDB_SW = -d
1925
1926 test :: \$(TEST_TYPE)
1927         \$(NOECHO) \$(NOOP)
1928
1929 testdb :: testdb_\$(LINKTYPE)
1930         \$(NOECHO) \$(NOOP)
1931
1932 ";
1933     foreach(@{$self->{DIR}}){
1934       my($vmsdir) = $self->fixpath($_,1);
1935       push(@m, '        If F$Search("',$vmsdir,'$(MAKEFILE)").nes."" Then $(PERL) -e "chdir ',"'$vmsdir'",
1936            '; print `$(MMS)$(MMSQUALIFIERS) $(PASTHRU2) test`'."\n");
1937     }
1938     push(@m, "\t\$(NOECHO) \$(SAY) \"No tests defined for \$(NAME) extension.\"\n")
1939         unless $tests or -f "test.pl" or @{$self->{DIR}};
1940     push(@m, "\n");
1941
1942     push(@m, "test_dynamic :: pure_all\n");
1943     push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
1944     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
1945     push(@m, "\t\$(NOECHO) \$(NOOP)\n") if (!$tests && ! -f "test.pl");
1946     push(@m, "\n");
1947
1948     push(@m, "testdb_dynamic :: pure_all\n");
1949     push(@m, $self->test_via_script('$(FULLPERL) "$(TESTDB_SW)"', '$(TEST_FILE)'));
1950     push(@m, "\n");
1951
1952     # Occasionally we may face this degenerate target:
1953     push @m, "test_ : test_dynamic\n\n";
1954
1955     if ($self->needs_linking()) {
1956         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
1957         push(@m, $self->test_via_harness('$(MAP_TARGET)', $tests)) if $tests;
1958         push(@m, $self->test_via_script('$(MAP_TARGET)', 'test.pl')) if -f 'test.pl';
1959         push(@m, "\n");
1960         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
1961         push(@m, $self->test_via_script('$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
1962         push(@m, "\n");
1963     }
1964     else {
1965         push @m, "test_static :: test_dynamic\n\t\$(NOECHO) \$(NOOP)\n\n";
1966         push @m, "testdb_static :: testdb_dynamic\n\t\$(NOECHO) \$(NOOP)\n";
1967     }
1968
1969     join('',@m);
1970 }
1971
1972 =item test_via_harness (override)
1973
1974 Use VMS-style quoting on command line.
1975
1976 =cut
1977
1978 sub test_via_harness {
1979     my($self,$perl,$tests) = @_;
1980     "   $perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)" \\'."\n\t".
1981     '-e "use Test::Harness qw(&runtests $verbose); $verbose=$(TEST_VERBOSE); runtests @ARGV;" \\'."\n\t$tests\n";
1982 }
1983
1984 =item test_via_script (override)
1985
1986 Use VMS-style quoting on command line.
1987
1988 =cut
1989
1990 sub test_via_script {
1991     my($self,$perl,$script) = @_;
1992     "   $perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" '.$script.'
1993 ';
1994 }
1995
1996 =item makeaperl (override)
1997
1998 Undertake to build a new set of Perl images using VMS commands.  Since
1999 VMS does dynamic loading, it's not necessary to statically link each
2000 extension into the Perl image, so this isn't the normal build path.
2001 Consequently, it hasn't really been tested, and may well be incomplete.
2002
2003 =cut
2004
2005 sub makeaperl {
2006     my($self, %attribs) = @_;
2007     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2008       @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2009     my(@m);
2010     push @m, "
2011 # --- MakeMaker makeaperl section ---
2012 MAP_TARGET    = $target
2013 ";
2014     return join '', @m if $self->{PARENT};
2015
2016     my($dir) = join ":", @{$self->{DIR}};
2017
2018     unless ($self->{MAKEAPERL}) {
2019         push @m, q{
2020 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2021         $(NOECHO) $(SAY) "Writing ""$(MMS$TARGET)"" for this $(MAP_TARGET)"
2022         $(NOECHO) $(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
2023                 Makefile.PL DIR=}, $dir, q{ \
2024                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2025                 MAKEAPERL=1 NORECURS=1
2026
2027 $(MAP_TARGET) :: $(MAKE_APERL_FILE)
2028         $(MMS)$(MMSQUALIFIERS)$(USEMAKEFILE)$(MAKE_APERL_FILE) static $(MMS$TARGET)
2029 };
2030         push @m, map( " \\\n\t\t$_", @ARGV );
2031         push @m, "\n";
2032
2033         return join '', @m;
2034     }
2035
2036
2037     my($linkcmd,@optlibs,@staticpkgs,$extralist,$targdir,$libperldir,%libseen);
2038     local($_);
2039
2040     # The front matter of the linkcommand...
2041     $linkcmd = join ' ', $Config{'ld'},
2042             grep($_, @Config{qw(large split ldflags ccdlflags)});
2043     $linkcmd =~ s/\s+/ /g;
2044
2045     # Which *.olb files could we make use of...
2046     local(%olbs);
2047     $olbs{$self->{INST_ARCHAUTODIR}} = "$self->{BASEEXT}\$(LIB_EXT)";
2048     require File::Find;
2049     File::Find::find(sub {
2050         return unless m/\Q$self->{LIB_EXT}\E$/;
2051         return if m/^libperl/;
2052
2053         if( exists $self->{INCLUDE_EXT} ){
2054                 my $found = 0;
2055                 my $incl;
2056                 my $xx;
2057
2058                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2059                 $xx =~ s,/?$_,,;
2060                 $xx =~ s,/,::,g;
2061
2062                 # Throw away anything not explicitly marked for inclusion.
2063                 # DynaLoader is implied.
2064                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2065                         if( $xx eq $incl ){
2066                                 $found++;
2067                                 last;
2068                         }
2069                 }
2070                 return unless $found;
2071         }
2072         elsif( exists $self->{EXCLUDE_EXT} ){
2073                 my $excl;
2074                 my $xx;
2075
2076                 ($xx = $File::Find::name) =~ s,.*?/auto/,,;
2077                 $xx =~ s,/?$_,,;
2078                 $xx =~ s,/,::,g;
2079
2080                 # Throw away anything explicitly marked for exclusion
2081                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2082                         return if( $xx eq $excl );
2083                 }
2084         }
2085
2086         $olbs{$ENV{DEFAULT}} = $_;
2087     }, grep( -d $_, @{$searchdirs || []}));
2088
2089     # We trust that what has been handed in as argument will be buildable
2090     $static = [] unless $static;
2091     @olbs{@{$static}} = (1) x @{$static};
2092
2093     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2094     # Sort the object libraries in inverse order of
2095     # filespec length to try to insure that dependent extensions
2096     # will appear before their parents, so the linker will
2097     # search the parent library to resolve references.
2098     # (e.g. Intuit::DWIM will precede Intuit, so unresolved
2099     # references from [.intuit.dwim]dwim.obj can be found
2100     # in [.intuit]intuit.olb).
2101     for (sort { length($a) <=> length($b) } keys %olbs) {
2102         next unless $olbs{$_} =~ /\Q$self->{LIB_EXT}\E$/;
2103         my($dir) = $self->fixpath($_,1);
2104         my($extralibs) = $dir . "extralibs.ld";
2105         my($extopt) = $dir . $olbs{$_};
2106         $extopt =~ s/$self->{LIB_EXT}$/.opt/;
2107         push @optlibs, "$dir$olbs{$_}";
2108         # Get external libraries this extension will need
2109         if (-f $extralibs ) {
2110             my %seenthis;
2111             open LIST,$extralibs or warn $!,next;
2112             while (<LIST>) {
2113                 chomp;
2114                 # Include a library in the link only once, unless it's mentioned
2115                 # multiple times within a single extension's options file, in which
2116                 # case we assume the builder needed to search it again later in the
2117                 # link.
2118                 my $skip = exists($libseen{$_}) && !exists($seenthis{$_});
2119                 $libseen{$_}++;  $seenthis{$_}++;
2120                 next if $skip;
2121                 push @$extra,$_;
2122             }
2123             close LIST;
2124         }
2125         # Get full name of extension for ExtUtils::Miniperl
2126         if (-f $extopt) {
2127             open OPT,$extopt or die $!;
2128             while (<OPT>) {
2129                 next unless /(?:UNIVERSAL|VECTOR)=boot_([\w_]+)/;
2130                 my $pkg = $1;
2131                 $pkg =~ s#__*#::#g;
2132                 push @staticpkgs,$pkg;
2133             }
2134         }
2135     }
2136     # Place all of the external libraries after all of the Perl extension
2137     # libraries in the final link, in order to maximize the opportunity
2138     # for XS code from multiple extensions to resolve symbols against the
2139     # same external library while only including that library once.
2140     push @optlibs, @$extra;
2141
2142     $target = "Perl$Config{'exe_ext'}" unless $target;
2143     ($shrtarget,$targdir) = fileparse($target);
2144     $shrtarget =~ s/^([^.]*)/$1Shr/;
2145     $shrtarget = $targdir . $shrtarget;
2146     $target = "Perlshr.$Config{'dlext'}" unless $target;
2147     $tmp = "[]" unless $tmp;
2148     $tmp = $self->fixpath($tmp,1);
2149     if (@optlibs) { $extralist = join(' ',@optlibs); }
2150     else          { $extralist = ''; }
2151     # Let ExtUtils::Liblist find the necessary libs for us (but skip PerlShr)
2152     # that's what we're building here).
2153     push @optlibs, grep { !/PerlShr/i } split ' ', +($self->ext())[2];
2154     if ($libperl) {
2155         unless (-f $libperl || -f ($libperl = $self->catfile($Config{'installarchlib'},'CORE',$libperl))) {
2156             print STDOUT "Warning: $libperl not found\n";
2157             undef $libperl;
2158         }
2159     }
2160     unless ($libperl) {
2161         if (defined $self->{PERL_SRC}) {
2162             $libperl = $self->catfile($self->{PERL_SRC},"libperl$self->{LIB_EXT}");
2163         } elsif (-f ($libperl = $self->catfile($Config{'installarchlib'},'CORE',"libperl$self->{LIB_EXT}")) ) {
2164         } else {
2165             print STDOUT "Warning: $libperl not found
2166     If you're going to build a static perl binary, make sure perl is installed
2167     otherwise ignore this warning\n";
2168         }
2169     }
2170     $libperldir = $self->fixpath((fileparse($libperl))[1],1);
2171
2172     push @m, '
2173 # Fill in the target you want to produce if it\'s not perl
2174 MAP_TARGET    = ',$self->fixpath($target,0),'
2175 MAP_SHRTARGET = ',$self->fixpath($shrtarget,0),"
2176 MAP_LINKCMD   = $linkcmd
2177 MAP_PERLINC   = ", $perlinc ? map('"$_" ',@{$perlinc}) : '',"
2178 MAP_EXTRA     = $extralist
2179 MAP_LIBPERL = ",$self->fixpath($libperl,0),'
2180 ';
2181
2182
2183     push @m,"\n${tmp}Makeaperl.Opt : \$(MAP_EXTRA)\n";
2184     foreach (@optlibs) {
2185         push @m,'       $(NOECHO) $(PERL) -e "print q{',$_,'}" >>$(MMS$TARGET)',"\n";
2186     }
2187     push @m,"\n${tmp}PerlShr.Opt :\n\t";
2188     push @m,'$(NOECHO) $(PERL) -e "print q{$(MAP_SHRTARGET)}" >$(MMS$TARGET)',"\n";
2189
2190 push @m,'
2191 $(MAP_SHRTARGET) : $(MAP_LIBPERL) Makeaperl.Opt ',"${libperldir}Perlshr_Attr.Opt",'
2192         $(MAP_LINKCMD)/Shareable=$(MMS$TARGET) $(MAP_LIBPERL), Makeaperl.Opt/Option ',"${libperldir}Perlshr_Attr.Opt/Option",'
2193 $(MAP_TARGET) : $(MAP_SHRTARGET) ',"${tmp}perlmain\$(OBJ_EXT) ${tmp}PerlShr.Opt",'
2194         $(MAP_LINKCMD) ',"${tmp}perlmain\$(OBJ_EXT)",', PerlShr.Opt/Option
2195         $(NOECHO) $(SAY) "To install the new ""$(MAP_TARGET)"" binary, say"
2196         $(NOECHO) $(SAY) "    $(MMS)$(MMSQUALIFIERS)$(USEMAKEFILE)$(MAKEFILE) inst_perl $(USEMACROS)MAP_TARGET=$(MAP_TARGET)$(ENDMACRO)"
2197         $(NOECHO) $(SAY) "To remove the intermediate files, say
2198         $(NOECHO) $(SAY) "    $(MMS)$(MMSQUALIFIERS)$(USEMAKEFILE)$(MAKEFILE) map_clean"
2199 ';
2200     push @m,"\n${tmp}perlmain.c : \$(MAKEFILE)\n\t\$(NOECHO) \$(PERL) -e 1 >${tmp}Writemain.tmp\n";
2201     push @m, "# More from the 255-char line length limit\n";
2202     foreach (@staticpkgs) {
2203         push @m,'       $(NOECHO) $(PERL) -e "print q{',$_,qq[}" >>${tmp}Writemain.tmp\n];
2204     }
2205         push @m,'
2206         $(NOECHO) $(PERL) $(MAP_PERLINC) -ane "use ExtUtils::Miniperl; writemain(@F)" ',$tmp,'Writemain.tmp >$(MMS$TARGET)
2207         $(NOECHO) $(RM_F) ',"${tmp}Writemain.tmp\n";
2208
2209     push @m, q[
2210 # Still more from the 255-char line length limit
2211 doc_inst_perl :
2212         $(NOECHO) $(PERL) -e "print 'Perl binary $(MAP_TARGET)|'" >.MM_tmp
2213         $(NOECHO) $(PERL) -e "print 'MAP_STATIC|$(MAP_STATIC)|'" >>.MM_tmp
2214         $(NOECHO) $(PERL) -pl040 -e " " ].$self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'),q[ >>.MM_tmp
2215         $(NOECHO) $(PERL) -e "print 'MAP_LIBPERL|$(MAP_LIBPERL)|'" >>.MM_tmp
2216         $(DOC_INSTALL) <.MM_tmp >>].$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
2217         $(NOECHO) Delete/NoLog/NoConfirm .MM_tmp;
2218 ];
2219
2220     push @m, "
2221 inst_perl : pure_inst_perl doc_inst_perl
2222         \$(NOECHO) \$(NOOP)
2223
2224 pure_inst_perl : \$(MAP_TARGET)
2225         $self->{CP} \$(MAP_SHRTARGET) ",$self->fixpath($Config{'installbin'},1),"
2226         $self->{CP} \$(MAP_TARGET) ",$self->fixpath($Config{'installbin'},1),"
2227
2228 clean :: map_clean
2229         \$(NOECHO) \$(NOOP)
2230
2231 map_clean :
2232         \$(RM_F) ${tmp}perlmain\$(OBJ_EXT) ${tmp}perlmain.c \$(MAKEFILE)
2233         \$(RM_F) ${tmp}Makeaperl.Opt ${tmp}PerlShr.Opt \$(MAP_TARGET)
2234 ";
2235
2236     join '', @m;
2237 }
2238
2239 # --- Output postprocessing section ---
2240
2241 =item nicetext (override)
2242
2243 Insure that colons marking targets are preceded by space, in order
2244 to distinguish the target delimiter from a colon appearing as
2245 part of a filespec.
2246
2247 =cut
2248
2249 sub nicetext {
2250
2251     my($self,$text) = @_;
2252     $text =~ s/([^\s:])(:+\s)/$1 $2/gs;
2253     $text;
2254 }
2255
2256 1;
2257
2258 =back
2259
2260 =cut
2261
2262 __END__
2263