lib/ExtUtils/MM_VMS.pm

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