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