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