This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
$nonono => $opts{notify}
[perl5.git] / installperl
1 #!./perl
2
3 BEGIN {
4     require 5.004;
5     chdir '..' if !-d 'lib' and -d '../lib';
6     @INC = 'lib';
7     $ENV{PERL5LIB} = 'lib';
8 }
9
10 BEGIN {
11     use Config;
12     if ($Config{userelocatableinc}) {
13         # This might be a considered a hack. Need to get information about the
14         # configuration from Config.pm *before* Config.pm expands any .../
15         # prefixes.
16         #
17         # So we set $^X to pretend that we're the already installed perl, so
18         # Config.pm doesits ... expansion off that location.
19
20         my $location = $Config{initialinstalllocation};
21         die <<'OS' unless defined $location;
22 $Config{initialinstalllocation} is not defined - can't install a relocatable
23 perl without this.
24 OS
25         $^X = "$location/perl";
26         # And then remove all trace of ever having loaded Config.pm, so that
27         # it will reload with the revised $^X
28         undef %Config::;
29         delete $INC{"Config.pm"};
30         delete $INC{"Config_heavy.pl"};
31         # You never saw us. We weren't here.
32     }
33 }
34
35 use strict;
36 my ($Is_VMS, $Is_W32, $Is_OS2, $Is_Cygwin, $Is_Darwin,
37     %opts, $dostrip, $versiononly, $force,
38     $otherperls, $archname, $Is_NetWare, $nwinstall, $nopods);
39 use vars qw /$depth/;
40
41 BEGIN {
42     $Is_VMS = $^O eq 'VMS';
43     $Is_W32 = $^O eq 'MSWin32';
44     $Is_OS2 = $^O eq 'os2';
45     $Is_Cygwin = $^O eq 'cygwin';
46     $Is_Darwin = $^O eq 'darwin';
47     if ($Is_VMS) { eval 'use VMS::Filespec;' }
48 }
49
50 my $scr_ext = ($Is_VMS ? '.Com' : $Is_W32 ? '.bat' : '');
51
52 use File::Find;
53 use File::Compare;
54 use File::Copy ();
55 use File::Path ();
56 use ExtUtils::Packlist;
57 use Cwd;
58 use Config;
59 use subs qw(unlink link chmod);
60
61 if ($Config{d_umask}) {
62     umask(022); # umasks like 077 aren't that useful for installations
63 }
64
65 $Is_NetWare = $Config{osname} eq 'NetWare';
66 if ($Is_NetWare) {
67     $Is_W32 = 0;
68     $scr_ext = '.pl';
69 }
70
71 # override the ones in the rest of the script
72 sub mkpath {
73     File::Path::mkpath(@_) unless $opts{notify};
74 }
75
76 my $mainperldir = "/usr/bin";
77 my $exe_ext = $Config{exe_ext};
78
79 # Allow ``make install PERLNAME=something_besides_perl'':
80 my $perl = defined($ENV{PERLNAME}) ? $ENV{PERLNAME} : 'perl';
81
82 # This is the base used for versioned names, like "perl5.6.0".
83 # It's separate because a common use of $PERLNAME is to install
84 # perl as "perl5", if that's used as base for versioned files you
85 # get "perl55.6.0".
86 my $perl_verbase = defined($ENV{PERLNAME_VERBASE})
87                     ? $ENV{PERLNAME_VERBASE}
88                     : $perl;
89 my $dbg = '';
90 my $ndbg = '';
91 if ( $Is_VMS ) {
92     if ( defined $Config{usevmsdebug} ) {
93         if ( $Config{usevmsdebug} eq 'define' ) {
94             $dbg = 'dbg';
95             $ndbg = 'ndbg';
96         }
97     }
98 }
99
100 $otherperls = 1;
101 my $destdir = '';
102 while (@ARGV) {
103     $opts{notify} = 1 if $ARGV[0] eq '-n';
104     $dostrip = 1 if $ARGV[0] eq '-s';
105     $versiononly = 1 if $ARGV[0] eq '-v';
106     $versiononly = 0 if $ARGV[0] eq '+v';
107     $opts{silent} = 1 if $ARGV[0] eq '-S';
108     $otherperls = 0 if $ARGV[0] eq '-o';
109     $force = 1 if $ARGV[0] eq '-f';
110     $opts{verbose} = 1 if $ARGV[0] eq '-V' || $ARGV [0] eq '-n';
111     $archname = 1 if $ARGV[0] eq '-A';
112     $nwinstall = 1 if $ARGV[0] eq '-netware';
113     $nopods = 1 if $ARGV[0] eq '-p';
114     $destdir = $1 if $ARGV[0] =~ /^-?-destdir=(.*)$/;
115     if ($ARGV[0] eq '-?' or $ARGV[0] =~ /^-?-h/) {
116         print <<"EOT";
117 Usage $0: [switches]
118   -n        Don't actually run any commands; just print them.
119   -s        Run strip on installed binaries.
120   -v        Only install perl as a binary with the version number in the name.
121             (Override whatever config.sh says)
122   +v        Install perl as "perl" and as a binary with the version number in
123             the name.  (Override whatever config.sh says)
124   -S        Silent mode.
125   -f        Force installation (don't check if same version is there)
126   -o        Skip checking for other copies of perl in your PATH.
127   -V        Verbose mode.
128   -A        Also install perl with the architecture's name in the perl binary's
129             name.
130   -p        Don't install the pod files. [This will break use diagnostics;]
131   -netware  Install correctly on a Netware server.
132   -destdir  Prefix installation directories by this string.
133 EOT
134         exit;
135     }
136     shift;
137 }
138
139 $versiononly = 1 if $Config{versiononly} && !defined $versiononly;
140 my (@scripts, @tolink);
141 open SCRIPTS, "utils.lst" or die "Can't open utils.lst: $!";
142 while (<SCRIPTS>) {
143     next if /^#/;
144     s/\s*#\s*pod\s*=.*//; # install script regardless of pod location
145     next if /a2p/; # a2p is binary, to be installed separately
146     chomp;
147     if (/(\S*)\s*#\s*link\s*=\s*(\S*)/) {
148         push @scripts, $1;
149         push @tolink, [$1, $2];
150     } else {
151         push @scripts, $_;
152     }
153 }
154 close SCRIPTS;
155
156 if ($scr_ext) { @scripts = map { "$_$scr_ext" } @scripts; }
157
158 my @pods = $nopods ? () : (<pod/*.pod>, 'x2p/a2p.pod');
159
160 # Specify here any .pm files that are actually architecture-dependent.
161 # (Those included with XS extensions under ext/ are automatically
162 # added later.)
163 # Now that the default privlib has the full perl version number included,
164 # we no longer have to play the trick of sticking version-specific .pm
165 # files under the archlib directory.
166 my %archpms = (
167     Config => 1,
168     lib => 1,
169     Cwd => 1,
170 );
171
172 if ($^O eq 'dos') {
173     push(@scripts,'djgpp/fixpmain');
174     $archpms{config} = $archpms{filehand} = 1;
175 }
176
177 if ((-e "testcompile") && (defined($ENV{'COMPILE'}))) {
178     push(@scripts, map("$_.exe", @scripts));
179 }
180
181 find(sub {
182     if ("$File::Find::dir/$_" =~ m{^ext\b(.*)/([^/]+)\.pm$}) {
183         my($path, $modname) = ($1,$2);
184
185         # strip to optional "/lib", or remove trailing component
186         $path =~ s{.*/lib\b}{} or $path =~ s{/[^/]*$}{};
187
188         # strip any leading /
189         $path =~ s{^/}{};
190
191         # reconstitute canonical module name
192         $modname = "$path/$modname" if length $path;
193
194         # remember it
195         $archpms{$modname} = 1;
196     }
197 }, 'ext');
198
199 # print "[$_]\n" for sort keys %archpms;
200
201 my $ver = $Config{version};
202 my $release = substr($],0,3);   # Not used currently.
203 my $patchlevel = substr($],3,2);
204 die "Patchlevel of perl ($patchlevel)",
205     "and patchlevel of config.sh ($Config{'PERL_VERSION'}) don't match\n"
206         if $patchlevel != $Config{'PERL_VERSION'};
207
208 # Fetch some frequently-used items from %Config
209 my $installbin = "$destdir$Config{installbin}";
210 my $installscript = "$destdir$Config{installscript}";
211 my $installprivlib = "$destdir$Config{installprivlib}";
212 my $installarchlib = "$destdir$Config{installarchlib}";
213 my $installsitelib = "$destdir$Config{installsitelib}";
214 my $installsitearch = "$destdir$Config{installsitearch}";
215 my $installman1dir = "$destdir$Config{installman1dir}";
216 my $man1ext = $Config{man1ext};
217 my $libperl = $Config{libperl};
218 # Shared library and dynamic loading suffixes.
219 my $so = $Config{so};
220 my $dlext = $Config{dlext};
221 my $dlsrc = $Config{dlsrc};
222 if ($^O eq 'os390') {
223     my $pwd;
224     chomp($pwd=`pwd`);
225     my $archlibexp = $Config{archlibexp};
226     my $usedl = $Config{usedl};
227     if ($usedl eq 'define') {
228         `./$^X -pibak -e 's{$pwd\/libperl.x}{$archlibexp/CORE/libperl.x}' lib/Config.pm`;
229     }
230 }
231
232 if ($nwinstall) {
233     # This is required only if we are installing on a NetWare server
234     $installscript = $Config{installnwscripts};
235     $installprivlib = $Config{installnwlib};
236     $installarchlib = $Config{installnwlib};
237     $installsitelib = $Config{installnwlib};
238 }
239
240 my $d_dosuid = $Config{d_dosuid};
241 my $binexp = $Config{binexp};
242
243 if ($Is_VMS) {  # Hang in there until File::Spec hits the big time
244     foreach ( \$installbin,     \$installscript,  \$installprivlib,
245               \$installarchlib, \$installsitelib, \$installsitearch,
246               \$installman1dir ) {
247         $$_ = unixify($$_);  $$_ =~ s:/$::;
248     }
249 }
250
251 # Do some quick sanity checks.
252
253 if (!$opts{notify} && $d_dosuid && $>) { die "You must run as root to install suidperl\n"; }
254
255    $installbin          || die "No installbin directory in config.sh\n";
256 -d $installbin          || mkpath($installbin, $opts{verbose}, 0777);
257 -d $installbin          || $opts{notify} || die "$installbin is not a directory\n";
258 -w $installbin          || $opts{notify} || die "$installbin is not writable by you\n"
259         unless $installbin =~ m#^/afs/# || $opts{notify};
260
261 if (!$Is_NetWare) {
262 if (!$Is_VMS) {
263 -x 'perl' . $exe_ext    || die "perl isn't executable!\n";
264 }
265 else {
266 -x $ndbg . 'perl' . $exe_ext    || die "${ndbg}perl$exe_ext isn't executable!\n";
267     if ($dbg) {
268         -x $dbg . 'perl' . $exe_ext     || die "${dbg}perl$exe_ext isn't executable!\n";
269     }
270 }
271 -x 'suidperl' . $exe_ext|| die "suidperl isn't executable!\n" if $d_dosuid;
272
273 -f 't/rantests'         || $Is_W32
274                         || warn "WARNING: You've never run 'make test' or",
275                                 " some tests failed! (Installing anyway.)\n";
276 } #if (!$Is_NetWare)
277
278 # This will be used to store the packlist
279 my $packlist = ExtUtils::Packlist->new("$installarchlib/.packlist");
280
281 if (($Is_W32 and ! $Is_NetWare) or $Is_Cygwin) {
282     my $perldll;
283
284     if ($Is_Cygwin) {
285         $perldll = $libperl;
286         my $v_e_r_s = substr($ver,0,-2); $v_e_r_s =~ tr/./_/;
287         $perldll =~ s/(\..*)?$/$v_e_r_s.$dlext/;
288         $perldll =~ s/^lib/cyg/;
289     } else {
290         $perldll = 'perl511.' . $dlext;
291     }
292
293     if ($dlsrc ne "dl_none.xs") {
294         -f $perldll || die "No perl DLL built\n";
295     }
296
297     # Install the DLL
298     safe_unlink("$installbin/$perldll");
299     copy("$perldll", "$installbin/$perldll");
300     chmod(0755, "$installbin/$perldll");
301     $packlist->{"$installbin/$perldll"} = { type => 'file' };
302 } # if (($Is_W32 and ! $Is_NetWare) or $Is_Cygwin)
303
304 # First we install the version-numbered executables.
305
306 if ($Is_VMS) {
307     safe_unlink("$installbin/perl_setup.com");
308     copy("perl_setup.com", "$installbin/perl_setup.com");
309     chmod(0755, "$installbin/perl_setup.com");
310     safe_unlink("$installbin/$dbg$perl$exe_ext");
311     copy("$dbg$perl$exe_ext", "$installbin/$dbg$perl$exe_ext");
312     chmod(0755, "$installbin/$dbg$perl$exe_ext");
313     safe_unlink("$installbin/$dbg${perl}shr$exe_ext");
314     copy("$dbg${perl}shr$exe_ext", "$installbin/$dbg${perl}shr$exe_ext");
315     chmod(0755, "$installbin/$dbg${perl}shr$exe_ext");
316     if ($ndbg) {
317         safe_unlink("$installbin/$ndbg$perl$exe_ext");
318         copy("$ndbg$perl$exe_ext", "$installbin/$ndbg$perl$exe_ext");
319         chmod(0755, "$installbin/$ndbg$perl$exe_ext");
320         safe_unlink("$installbin/${dbg}a2p$exe_ext");
321         copy("x2p/${dbg}a2p$exe_ext", "$installbin/${dbg}a2p$exe_ext");
322         chmod(0755, "$installbin/${dbg}a2p$exe_ext");
323     }
324 }
325 elsif ($^O eq 'mpeix') {
326     # MPE lacks hard links and requires that executables with special
327     # capabilities reside in the MPE namespace.
328     safe_unlink("$installbin/perl$ver$exe_ext", $Config{perlpath});
329     # Install the primary executable into the MPE namespace as perlpath.
330     copy("perl$exe_ext", $Config{perlpath});
331     chmod(0755, $Config{perlpath});
332     # Create a backup copy with the version number.
333     link($Config{perlpath}, "$installbin/perl$ver$exe_ext");
334 }
335 elsif ($^O ne 'dos') {
336     if (!$Is_NetWare) {
337         safe_unlink("$installbin/$perl_verbase$ver$exe_ext");
338         copy("perl$exe_ext", "$installbin/$perl_verbase$ver$exe_ext");
339         strip("$installbin/$perl_verbase$ver$exe_ext");
340         chmod(0755, "$installbin/$perl_verbase$ver$exe_ext");
341     }
342     else {
343         # If installing onto a NetWare server
344         if ($nwinstall) {
345             # Copy perl.nlm, echo.nlm, type.nlm, a2p.nlm & cgi2perl.nlm
346             mkpath($Config{installnwsystem}, 1, 0777);
347             copy("netware\\".$ENV{'MAKE_TYPE'}."\\perl.nlm", $Config{installnwsystem});
348             copy("netware\\testnlm\\echo\\echo.nlm", $Config{installnwsystem});
349             copy("netware\\testnlm\\type\\type.nlm", $Config{installnwsystem});
350             copy("x2p\\a2p.nlm", $Config{installnwsystem});
351             chmod(0755, "$Config{installnwsystem}\\perl.nlm");
352             mkpath($Config{installnwlcgi}, 1, 0777);
353             copy("lib\\auto\\cgi2perl\\cgi2perl.nlm", $Config{installnwlcgi});
354         }
355     } #if (!$Is_NetWare)
356 }
357 else {
358     safe_unlink("$installbin/$perl.exe");
359     copy("perl.exe", "$installbin/$perl.exe");
360 }
361
362 safe_unlink("$installbin/s$perl_verbase$ver$exe_ext");
363 if ($d_dosuid) {
364     copy("suidperl$exe_ext", "$installbin/s$perl_verbase$ver$exe_ext");
365     chmod(04711, "$installbin/s$perl_verbase$ver$exe_ext");
366 }
367
368 # Install library files.
369
370 my ($do_installarchlib, $do_installprivlib) = (0, 0);
371 my $vershort = $Is_Cygwin ? substr($ver,0,-2) : $ver;
372
373 mkpath($installprivlib, $opts{verbose}, 0777);
374 mkpath($installarchlib, $opts{verbose}, 0777);
375 mkpath($installsitelib, $opts{verbose}, 0777) if ($installsitelib);
376 mkpath($installsitearch, $opts{verbose}, 0777) if ($installsitearch);
377
378 if (chdir "lib") {
379     $do_installarchlib = ! samepath($installarchlib, '.');
380     $do_installprivlib = ! samepath($installprivlib, '.');
381     $do_installprivlib = 0 if $versiononly && !($installprivlib =~ m/\Q$vershort/);
382
383     if ($do_installarchlib || $do_installprivlib) {
384         find(\&installlib, '.');
385     }
386     chdir ".." || die "Can't cd back to source directory: $!\n";
387 }
388 else {
389     warn "Can't cd to lib to install lib files: $!\n";
390 }
391
392 # Install header files and libraries.
393 mkpath("$installarchlib/CORE", $opts{verbose}, 0777);
394 my @corefiles;
395 if ($Is_VMS) {  # We did core file selection during build
396     my $coredir = "lib/$Config{archname}/$ver/CORE";
397     $coredir =~ tr/./_/;
398     map { s|^$coredir/||i; } @corefiles = <$coredir/*.*>;
399 }
400 else {
401     # [als] hard-coded 'libperl' name... not good!
402     @corefiles = <*.h libperl*.* perl*$Config{lib_ext}>;
403
404     # AIX needs perl.exp installed as well.
405     push(@corefiles,'perl.exp') if $^O eq 'aix';
406     if ($^O eq 'mpeix') {
407         # MPE needs mpeixish.h installed as well.
408         mkpath("$installarchlib/CORE/mpeix", $opts{verbose}, 0777);
409         push(@corefiles,'mpeix/mpeixish.h');
410     }
411     # If they have built sperl.o...
412     push(@corefiles,'sperl.o') if -f 'sperl.o';
413 }
414 foreach my $file (@corefiles) {
415     # HP-UX (at least) needs to maintain execute permissions
416     # on dynamically-loadable libraries. So we do it for all.
417     if (copy_if_diff($file,"$installarchlib/CORE/$file")) {
418         if ($file =~ /\.(\Q$so\E|\Q$dlext\E)$/) {
419             strip("-S", "$installarchlib/CORE/$file") if $^O =~ /^(rhapsody|darwin)$/;
420             chmod(0555, "$installarchlib/CORE/$file");
421         } else {
422             chmod(0444, "$installarchlib/CORE/$file");
423         }
424     }
425 }
426
427 # Install main perl executables
428 # Make links to ordinary names if installbin directory isn't current directory.
429
430 if (! $versiononly && ! samepath($installbin, '.') && ($^O ne 'dos') && ! $Is_VMS && ! $Is_NetWare) {
431     safe_unlink("$installbin/$perl$exe_ext", "$installbin/suid$perl$exe_ext");
432     if ($^O eq 'mpeix') {
433         # MPE doesn't support hard links, so use a symlink.
434         # We don't want another cloned copy.
435         symlink($Config{perlpath}, "$installbin/perl$exe_ext");
436     } elsif ($^O eq 'vos') {
437         # VOS doesn't support hard links, so use a symlink.
438         symlink("$installbin/$perl_verbase$ver$exe_ext",
439                 "$installbin/$perl$exe_ext");
440     } else {
441         link("$installbin/$perl_verbase$ver$exe_ext",
442                 "$installbin/$perl$exe_ext");
443     }
444     link("$installbin/$perl_verbase$ver$exe_ext",
445             "$installbin/suid$perl$exe_ext")
446       if $d_dosuid;
447 }
448
449 # For development purposes it can be very useful to have multiple perls
450 # build for different "architectures" (eg threading or not) simultaneously.
451 if ($archname && ! samepath($installbin, '.') && ($^O ne 'dos') && ! $Is_VMS) {
452     my $archperl = "$perl_verbase$ver-$Config{archname}$exe_ext";
453     safe_unlink("$installbin/$archperl");
454     if ($^O eq 'mpeix') {
455         # MPE doesn't support hard links, so use a symlink.
456         # We don't want another cloned copy.
457         symlink($Config{perlpath}, "$installbin/$archperl");
458     } elsif ($^O eq 'vos') {
459         # VOS doesn't support hard links, so use a symlink.
460         symlink("$installbin/$perl_verbase$ver$exe_ext",
461                 "$installbin/$archperl");
462     } else {
463         link("$installbin/$perl_verbase$ver$exe_ext", "$installbin/$archperl");
464     }
465 }
466
467 # Offer to install perl in a "standard" location
468
469 my $mainperl_is_instperl = 0;
470
471 if ($Config{installusrbinperl} && $Config{installusrbinperl} eq 'define' &&
472     !$versiononly && !$opts{notify} && !$Is_W32 && !$Is_NetWare && !$Is_VMS && -t STDIN && -t STDERR
473         && -w $mainperldir && ! samepath($mainperldir, $installbin)) {
474     my($usrbinperl)     = "$mainperldir/$perl$exe_ext";
475     my($instperl)       = "$installbin/$perl$exe_ext";
476     my($expinstperl)    = "$binexp/$perl$exe_ext";
477
478     # First make sure $usrbinperl is not already the same as the perl we
479     # just installed.
480     if (-x $usrbinperl) {
481         # Try to be clever about mainperl being a symbolic link
482         # to binexp/perl if binexp and installbin are different.
483         $mainperl_is_instperl =
484             samepath($usrbinperl, $instperl) ||
485             samepath($usrbinperl, $expinstperl) ||
486              (($binexp ne $installbin) &&
487               (-l $usrbinperl) &&
488               ((readlink $usrbinperl) eq $expinstperl));
489     }
490     if (! $mainperl_is_instperl) {
491         unlink($usrbinperl);
492         ( $Config{'d_link'} eq 'define' &&
493           eval { CORE::link $instperl, $usrbinperl } )  ||
494         eval { symlink $expinstperl, $usrbinperl }      ||
495         copy($instperl, $usrbinperl);
496
497         $mainperl_is_instperl = 1;
498     }
499 }
500
501 # Make links to ordinary names if installbin directory isn't current directory.
502 if (!$Is_NetWare && $dbg eq '') {
503     if (! samepath($installbin, 'x2p')) {
504         my $base = 'a2p';
505         $base .= $ver if $versiononly;
506         safe_unlink("$installbin/$base$exe_ext");
507         copy("x2p/a2p$exe_ext", "$installbin/$base$exe_ext");
508         strip("$installbin/$base$exe_ext");
509         chmod(0755, "$installbin/$base$exe_ext");
510     }
511 }
512
513 # cppstdin is just a script, but it is architecture-dependent, so
514 # it can't safely be shared.  Place it in $installbin.
515 # Note that Configure doesn't build cppstin if it isn't needed, so
516 # we skip this if cppstdin doesn't exist.
517 if (! $versiononly && (-f 'cppstdin') && (! samepath($installbin, '.'))) {
518     safe_unlink("$installbin/cppstdin");
519     copy("cppstdin", "$installbin/cppstdin");
520     chmod(0755, "$installbin/cppstdin");
521 }
522
523 sub script_alias {
524     my ($installscript, $orig, $alias, $scr_ext) = @_;
525
526     safe_unlink("$installscript/$alias$scr_ext");
527     if ($^O eq 'dos' or $Is_VMS or $^O eq 'transit') {
528         copy("$installscript/$orig$scr_ext",
529              "$installscript/$alias$scr_ext");
530     } elsif ($^O eq 'vos') {
531         symlink("$installscript/$orig$scr_ext",
532                 "$installscript/$alias$scr_ext");
533     } else {
534         link("$installscript/$orig$scr_ext",
535              "$installscript/$alias$scr_ext");
536     }
537 }
538
539 # Install scripts.
540 mkpath($installscript, $opts{verbose}, 0777);
541 if ($versiononly) {
542     for (@scripts) {
543         (my $base = $_) =~ s#.*/##;
544         $base .= $ver;
545         copy($_,    "$installscript/$base");
546         chmod(0755, "$installscript/$base");
547     }
548
549     for (@tolink) {
550         my ($from, $to) = map { "$_$ver" } @$_;
551         (my $frbase = $from) =~ s#.*/##;
552         (my $tobase = $to) =~ s#.*/##;
553         script_alias($installscript, $frbase, $tobase, $scr_ext);
554     }
555 } else {
556     for (@scripts) {
557         (my $base = $_) =~ s#.*/##;
558         copy($_, "$installscript/$base");
559         chmod(0755, "$installscript/$base");
560     }
561
562     for (@tolink) {
563         my ($from, $to) = @$_;
564         (my $frbase = $from) =~ s#.*/##;
565         (my $tobase = $to) =~ s#.*/##;
566         script_alias($installscript, $frbase, $tobase, $scr_ext);
567     }
568 }
569
570 # Install pod pages.  Where? I guess in $installprivlib/pod
571 # ($installprivlib/pods for cygwin).
572
573 my $pod = ($Is_Cygwin || $Is_Darwin || $Is_VMS || $Is_W32) ? 'pods' : 'pod';
574 if ( !$versiononly || ($installprivlib =~ m/\Q$vershort/)) {
575     mkpath("${installprivlib}/$pod", $opts{verbose}, 0777);
576
577     # If Perl 5.003's perldiag.pod is there, rename it.
578     if (open POD, "${installprivlib}/$pod/perldiag.pod") {
579         read POD, $_, 4000;
580         close POD;
581         # Some of Perl 5.003's diagnostic messages ended with periods.
582         if (/^=.*\.$/m) {
583             my ($from, $to) = ("${installprivlib}/$pod/perldiag.pod",
584                                "${installprivlib}/$pod/perldiag-5.003.pod");
585             print "  rename $from $to";
586             rename($from, $to)
587                 or warn "Couldn't rename $from to $to: $!\n"
588                 unless $opts{notify};
589         }
590     }
591
592     for (@pods) {
593         # $_ is a name like  pod/perl.pod
594         (my $base = $_) =~ s#.*/##;
595         copy_if_diff($_, "${installprivlib}/$pod/${base}");
596     }
597
598 }
599
600 # Check to make sure there aren't other perls around in installer's
601 # path.  This is probably UNIX-specific.  Check all absolute directories
602 # in the path except for where public executables are supposed to live.
603 # Also skip $mainperl if the user opted to have it be a link to the
604 # installed perl.
605
606 if (!$versiononly && $otherperls) {
607     my ($path, @path);
608     my $dirsep = ($Is_OS2 || $Is_W32 || $Is_NetWare) ? ';' : ':' ;
609     ($path = $ENV{"PATH"}) =~ s:\\:/:g ;
610     @path = split(/$dirsep/, $path);
611     if ($Is_VMS) {
612         my $i = 0;
613         while (exists $ENV{'DCL$PATH' . $i}) {
614             my $dir = unixpath($ENV{'DCL$PATH' . $i});  $dir =~ s-/$--;
615             push(@path,$dir);
616         }
617     }
618     my @otherperls;
619     my %otherperls;
620     for (@path) {
621         next unless m,^/,;
622         # Use &samepath here because some systems have other dirs linked
623         # to $mainperldir (like SunOS)
624         next if samepath($_, $binexp);
625         next if samepath($_, cwd());
626         next if ($mainperl_is_instperl && samepath($_, $mainperldir));
627         my $otherperl = "$_/$perl$exe_ext";
628         next if $otherperls{$otherperl}++;
629         push(@otherperls, $otherperl)
630             if (-x $otherperl && ! -d $otherperl);
631     }
632     if (@otherperls) {
633         warn "\nWarning: $perl appears in your path in the following " .
634             "locations beyond where\nwe just installed it:\n";
635         for (@otherperls) {
636             warn "    ", $_, "\n";
637         }
638         warn "\n";
639     }
640
641 }
642
643 $packlist->write() unless $opts{notify};
644 print "  Installation complete\n" if $opts{verbose};
645
646 exit 0;
647
648 ###############################################################################
649
650 sub yn {
651     my($prompt) = @_;
652     my($answer);
653     my($default) = $prompt =~ m/\[([yn])\]\s*$/i;
654     print STDERR $prompt;
655     chop($answer = <STDIN>);
656     $answer = $default if $answer =~ m/^\s*$/;
657     ($answer =~ m/^[yY]/);
658 }
659
660 sub unlink {
661     my(@names) = @_;
662     my($cnt) = 0;
663
664     return scalar(@names) if $Is_VMS;
665
666     foreach my $name (@names) {
667         next unless -e $name;
668         chmod 0777, $name if ($Is_OS2 || $Is_W32 || $Is_Cygwin || $Is_NetWare);
669         print "  unlink $name\n" if $opts{verbose};
670         ( CORE::unlink($name) and ++$cnt
671           or warn "Couldn't unlink $name: $!\n" ) unless $opts{notify};
672     }
673     return $cnt;
674 }
675
676 sub safe_unlink {
677     return if $opts{notify} or $Is_VMS;
678     my @names = @_;
679     foreach my $name (@names) {
680         next unless -e $name;
681         chmod 0777, $name if ($Is_OS2 || $Is_W32 || $Is_NetWare);
682         print "  unlink $name\n" if $opts{verbose};
683         next if CORE::unlink($name);
684         warn "Couldn't unlink $name: $!\n";
685         if ($! =~ /busy/i) {
686             print "  mv $name $name.old\n" if $opts{verbose};
687             safe_rename($name, "$name.old")
688                 or warn "Couldn't rename $name: $!\n";
689         }
690     }
691 }
692
693 sub safe_rename {
694     my($from,$to) = @_;
695     if (-f $to and not unlink($to)) {
696         my($i);
697         for ($i = 1; $i < 50; $i++) {
698             last if rename($to, "$to.$i");
699         }
700         warn("Cannot rename to `$to.$i': $!"), return 0
701            if $i >= 50; # Give up!
702     }
703     link($from,$to) || return 0;
704     unlink($from);
705 }
706
707 sub link {
708     my($from,$to) = @_;
709     my($success) = 0;
710
711     my $xfrom = $from;
712     $xfrom =~ s/^\Q$destdir\E// if $destdir;
713     my $xto = $to;
714     $xto =~ s/^\Q$destdir\E// if $destdir;
715     print $opts{verbose} ? "  ln $xfrom $xto\n" : "  $xto\n"
716         unless $opts{silent};
717     eval {
718         CORE::link($from, $to)
719             ? $success++
720             : ($from =~ m#^/afs/# || $to =~ m#^/afs/#)
721               ? die "AFS"  # okay inside eval {}
722               : die "Couldn't link $from to $to: $!\n"
723           unless $opts{notify};
724         $packlist->{$xto} = { from => $xfrom, type => 'link' };
725     };
726     if ($@) {
727         warn "Replacing link() with File::Copy::copy(): $@";
728         print $opts{verbose} ? "  cp $from $xto\n" : "  $xto\n"
729             unless $opts{silent};
730         print "  creating new version of $xto\n"
731                  if $Is_VMS and -e $to and !$opts{silent};
732         unless ($opts{notify} or File::Copy::copy($from, $to) and ++$success) {
733             # Might have been that F::C::c can't overwrite the target
734             warn "Couldn't copy $from to $to: $!\n"
735                 unless -f $to and (chmod(0666, $to), unlink $to)
736                         and File::Copy::copy($from, $to) and ++$success;
737         }
738         $packlist->{$xto} = { type => 'file' };
739     }
740     $success;
741 }
742
743 sub chmod {
744     my($mode,$name) = @_;
745
746     return if ($^O eq 'dos');
747     printf "  chmod %o %s\n", $mode, $name if $opts{verbose};
748     CORE::chmod($mode,$name)
749         || warn sprintf("Couldn't chmod %o %s: $!\n", $mode, $name)
750       unless $opts{notify};
751 }
752
753 sub copy {
754     my($from,$to) = @_;
755
756     my $xto = $to;
757     $xto =~ s/^\Q$destdir\E// if $destdir;
758     print $opts{verbose} ? "  cp $from $xto\n" : "  $xto\n"
759         unless $opts{silent};
760     print "  creating new version of $xto\n"
761         if $Is_VMS and -e $to and !$opts{silent};
762     unless ($opts{notify} or File::Copy::copy($from, $to)) {
763         # Might have been that F::C::c can't overwrite the target
764         warn "Couldn't copy $from to $to: $!\n"
765             unless -f $to and (chmod(0666, $to), unlink $to)
766                    and File::Copy::copy($from, $to);
767     }
768     $packlist->{$xto} = { type => 'file' };
769 }
770
771 sub samepath {
772     my($p1, $p2) = @_;
773
774     return (lc($p1) eq lc($p2)) if ($Is_W32 || $Is_NetWare);
775
776     if ($p1 ne $p2) {
777         my($dev1, $ino1, $dev2, $ino2);
778         ($dev1, $ino1) = stat($p1);
779         ($dev2, $ino2) = stat($p2);
780         ($dev1 == $dev2 && $ino1 == $ino2);
781     }
782     else {
783         1;
784     }
785 }
786
787 sub installlib {
788     my $dir = $File::Find::dir;
789     $dir =~ s#^\.(?![^/])/?##;
790     local($depth) = $dir ? "lib/$dir" : "lib";
791
792     my $name = $_;
793
794     # Ignore version control directories.
795     if ($name =~ /^(?:CVS|RCS|SCCS|\.svn)\z/ and -d $name) {
796         $File::Find::prune = 1;
797         return;
798     }
799
800     # ignore patch backups, RCS files, emacs backup & temp files and the
801     # .exists files, .PL files, and test files.
802     return if $name =~ m{\.orig$|\.rej$|~$|^#.+#$|,v$|^\.exists|\.PL$|\.plc$|\.t$|^test\.pl$|^dbm_filter_util.pl$} ||
803               $dir  =~ m{/t(?:/|$)};
804     # ignore the cpan script in lib/CPAN/bin, the instmodsh and xsubpp
805     # scripts in lib/ExtUtils, the prove script in lib/Test/Harness,
806     # the corelist script from lib/Module/CoreList/bin and ptar* in
807     # lib/Archive/Tar/bin, the config_data script in lib/Module/Build/scripts
808     # (they're installed later with other utils)
809     return if $name =~ /^(?:cpan|instmodsh|prove|corelist|ptar|cpan2dist|cpanp|cpanp-run-perl|ptardiff|config_data)\z/;
810     # ignore the Makefiles
811     return if $name =~ /^makefile$/i;
812     # ignore the test extensions
813     return if $dir =~ m{\bXS/(?:APItest|Typemap)\b};
814     return if $name =~ m{\b(?:APItest|Typemap)\.pm$};
815     # ignore the demo files
816     return if $dir =~ /\b(?:demos?|eg)\b/;
817
818     # ignore READMEs, MANIFESTs, INSTALL docs, META.ymls and change logs.
819     # Changes.e2x and README.e2x are needed by enc2xs.
820     return if $name =~ m{^(?:README(?:\.\w+)?)$} && $name ne 'README.e2x';
821     return if $name =~ m{^(?:MANIFEST|META\.yml)$};
822     return if $name =~ m{^(?:INSTALL|TODO|BUGS|CREDITS)$}i;
823     return if $name =~ m{^change(?:s|log)(?:\.libnet)?$}i;
824     return if $name =~ m{^(?:SIGNATURE|PAUSE200\d\.pub)$}; # CPAN files
825     return if $name =~ m{^(?:NOTES|PATCHING)$}; # ExtUtils files
826
827     # if using a shared perl library then ignore:
828     # - static library files [of statically linked extensions];
829     # - import library files and export library files (only present on Win32
830     #   anyway?) and empty bootstrap files [of dynamically linked extensions].
831     return if $Config{useshrplib} eq 'true' and
832              ($name =~ /$Config{_a}$/ or $name =~ /\.exp$/ or ($name =~ /\.bs$/ and -z $name));
833
834     $name = "$dir/$name" if $dir ne '';
835
836     my $installlib = $installprivlib;
837     if ($dir =~ /^auto/ ||
838           ($name =~ /^(.*)\.(?:pm|pod)$/ && $archpms{$1}) ||
839           ($name =~ /^(.*)\.(?:h|lib)$/i && ($Is_W32 || $Is_NetWare)) ||
840           $name eq 'Config_heavy.pl'
841        ) {
842         $installlib = $installarchlib;
843         return unless $do_installarchlib;
844     } else {
845         return unless $do_installprivlib;
846     }
847
848     if (-f $_) {
849         if (/\.(?:al|ix)$/ && !($dir =~ m[^auto/(.*)$])) {
850             $installlib = $installprivlib;
851             #We're installing *.al and *.ix files into $installprivlib,
852             #but we have to delete old *.al and *.ix files from the 5.000
853             #distribution:
854             #This might not work because $archname might have changed.
855             unlink("$installarchlib/$name");
856         }
857         my $xname = "$installlib/$name";
858         $xname =~ s/^\Q$destdir\E// if $destdir;
859         $packlist->{$xname} = { type => 'file' };
860         if ($force || compare($_, "$installlib/$name") || $opts{notify}) {
861             unlink("$installlib/$name");
862             mkpath("$installlib/$dir", $opts{verbose}, 0777);
863             # HP-UX (at least) needs to maintain execute permissions
864             # on dynamically-loaded libraries.
865             if ($Is_NetWare && !$nwinstall) {
866                 # Don't copy .nlp,.nlm files, doesn't make sense on Windows and also
867                 # if copied will give problems when building new extensions.
868                 # Has to be copied if we are installing on a NetWare server and hence
869                 # the check !$nwinstall
870                 if (!(/\.(?:nlp|nlm|bs)$/)) {
871                     copy_if_diff($_, "$installlib/$name")
872                         and chmod($name =~ /\.(so|$dlext)$/o ? 0555 : 0444,
873                                   "$installlib/$name");
874                 }
875            } else {
876                 if (copy_if_diff($_, "$installlib/$name")) {
877                     if ($name =~ /\.(so|$dlext)$/o) {
878                         strip("-S", "$installlib/$name") if $^O =~ /^(rhapsody|darwin)$/;
879                         chmod(0555, "$installlib/$name");
880                     } else {
881                         strip("-S", "$installlib/$name")
882                             if ($name =~ /\.a$/o and $^O =~ /^(rhapsody|darwin)$/);
883                         chmod(0444, "$installlib/$name");
884                     }
885                 }
886             } #if ($Is_NetWare)
887         }
888     }
889 }
890
891 # Copy $from to $to, only if $from is different than $to.
892 # Also preserve modification times for .a libraries.
893 # On some systems, if you do
894 #   ranlib libperl.a
895 #   cp libperl.a /usr/local/lib/perl5/archlib/CORE/libperl.a
896 # and then try to link against the installed libperl.a, you might
897 # get an error message to the effect that the symbol table is older
898 # than the library.
899 # Return true if copying occurred.
900
901 sub copy_if_diff {
902     my($from,$to)=@_;
903     return 1 if (($^O eq 'VMS') && (-d $from));
904     my $xto = $to;
905     $xto =~ s/^\Q$destdir\E// if $destdir;
906     my $perlpodbadsymlink;
907     if ($from =~ m!^pod/perl[\w-]+\.pod$! &&
908         -l $from &&
909         ! -e $from) {
910         # Some Linux implementations have problems traversing over
911         # multiple symlinks (when going over NFS?) and fail to read
912         # the symlink target.  Combine this with the fact that some
913         # of the pod files (the perl$OS.pod) are symlinks (to ../README.$OS),
914         # and you end up with those pods not getting installed.
915         $perlpodbadsymlink = 1;
916     }
917     -f $from || $perlpodbadsymlink || warn "$0: $from not found";
918     $packlist->{$xto} = { type => 'file' };
919     if ($force || compare($from, $to) || $opts{notify}) {
920         safe_unlink($to);   # In case we don't have write permissions.
921         if ($opts{notify}) {
922             $from = $depth . "/" . $from if $depth;
923         }
924         if ($perlpodbadsymlink && $from =~ m!^pod/perl(.+)\.pod$!) {
925             $from = "README.$1";
926         }
927         copy($from, $to);
928         # Restore timestamps if it's a .a library or for OS/2.
929         if (!$opts{notify} && ($Is_OS2 || $to =~ /\.a$/)) {
930             my ($atime, $mtime) = (stat $from)[8,9];
931             utime $atime, $mtime, $to;
932         }
933         1;
934     }
935 }
936
937 sub strip
938 {
939     my(@args) = @_;
940
941     return unless $dostrip;
942
943     my @opts;
944     while (@args && $args[0] =~ /^(-\w+)$/) {
945         push @opts, shift @args;
946     }
947
948     foreach my $file (@args) {
949         if (-f $file) {
950             if ($opts{verbose}) {
951                 print "  strip " . join(' ', @opts);
952                 print " " if (@opts);
953                 print "$file\n";
954             }
955             system("strip", @opts, $file);
956         } else {
957             print "# file '$file' skipped\n" if $opts{verbose};
958         }
959     }
960 }