utils/perldoc.PL

   1 #!/usr/local/bin/perl
   2
   3 use Config;
   4 use File::Basename qw(&basename &dirname);
   5 use Cwd;
   6
   7 # List explicitly here the variables you want Configure to
   8 # generate.  Metaconfig only looks for shell variables, so you
   9 # have to mention them as if they were shell variables, not
  10 # %Config entries.  Thus you write
  11 #  $startperl
  12 # to ensure Configure will look for $Config{startperl}.
  13
  14 # This forces PL files to create target in same directory as PL file.
  15 # This is so that make depend always knows where to find PL derivatives.
  16 $origdir = cwd;
  17 chdir dirname($0);
  18 $file = basename($0, '.PL');
  19 $file .= '.com' if $^O eq 'VMS';
  20
  21 open OUT,">$file" or die "Can't create $file: $!";
  22
  23 print "Extracting $file (with variable substitutions)\n";
  24
  25 # In this section, perl variables will be expanded during extraction.
  26 # You can use $Config{...} to use Configure variables.
  27
  28 print OUT <<"!GROK!THIS!";
  29 $Config{startperl}
  30     eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
  31         if 0;
  32
  33 use strict;
  34 my \@pagers = ();
  35 push \@pagers, "$Config{'pager'}" if -x "$Config{'pager'}";
  36 !GROK!THIS!
  37
  38 # In the following, perl variables are not expanded during extraction.
  39
  40 print OUT <<'!NO!SUBS!';
  41
  42 #
  43 # Perldoc revision #1 -- look up a piece of documentation in .pod format that
  44 # is embedded in the perl installation tree.
  45 #
  46 # This is not to be confused with Tom Christianson's perlman, which is a
  47 # man replacement, written in perl. This perldoc is strictly for reading
  48 # the perl manuals, though it too is written in perl.
  49
  50 if(@ARGV<1) {
  51         my $me = $0;            # Editing $0 is unportable
  52         $me =~ s,.*/,,;
  53         die <<EOF;
  54 Usage: $me [-h] [-r] [-i] [-v] [-t] [-u] [-m] [-l] [-F] [-X] PageName|ModuleName|ProgramName
  55        $me -f PerlFunc
  56        $me -q FAQKeywords
  57
  58 The -h option prints more help.  Also try "perldoc perldoc" to get
  59 aquainted with the system.
  60 EOF
  61 }
  62
  63 use Getopt::Std;
  64 use Config '%Config';
  65
  66 my @global_found = ();
  67 my $global_target = "";
  68
  69 my $Is_VMS = $^O eq 'VMS';
  70 my $Is_MSWin32 = $^O eq 'MSWin32';
  71 my $Is_Dos = $^O eq 'dos';
  72
  73 sub usage{
  74     warn "@_\n" if @_;
  75     # Erase evidence of previous errors (if any), so exit status is simple.
  76     $! = 0;
  77     die <<EOF;
  78 perldoc [options] PageName|ModuleName|ProgramName...
  79 perldoc [options] -f BuiltinFunction
  80 perldoc [options] -q FAQRegex
  81
  82 Options:
  83     -h   Display this help message
  84     -r   Recursive search (slow)
  85     -i   Ignore case
  86     -t   Display pod using pod2text instead of pod2man and nroff
  87              (-t is the default on win32)
  88     -u   Display unformatted pod text
  89     -m   Display module's file in its entirety
  90     -l   Display the module's file name
  91     -F   Arguments are file names, not modules
  92     -v   Verbosely describe what's going on
  93     -X   use index if present (looks for pod.idx at $Config{archlib})
  94     -q   Search the text of questions (not answers) in perlfaq[1-9]
  95
  96 PageName|ModuleName...
  97          is the name of a piece of documentation that you want to look at. You
  98          may either give a descriptive name of the page (as in the case of
  99          `perlfunc') the name of a module, either like `Term::Info',
 100          `Term/Info', the partial name of a module, like `info', or
 101          `makemaker', or the name of a program, like `perldoc'.
 102
 103 BuiltinFunction
 104          is the name of a perl function.  Will extract documentation from
 105          `perlfunc'.
 106
 107 FAQRegex
 108          is a regex. Will search perlfaq[1-9] for and extract any
 109          questions that match.
 110
 111 Any switches in the PERLDOC environment variable will be used before the
 112 command line arguments.  The optional pod index file contains a list of
 113 filenames, one per line.
 114
 115 EOF
 116 }
 117
 118 if( defined $ENV{"PERLDOC"} ) {
 119     require Text::ParseWords;
 120     unshift(@ARGV, Text::ParseWords::shellwords($ENV{"PERLDOC"}));
 121 }
 122 !NO!SUBS!
 123
 124 my $getopts = "mhtluvriFf:Xq:";
 125 print OUT <<"!GET!OPTS!";
 126
 127 use vars qw( @{[map "\$opt_$_", ($getopts =~ /\w/g)]} );
 128
 129 getopts("$getopts") || usage;
 130 !GET!OPTS!
 131
 132 print OUT <<'!NO!SUBS!';
 133
 134 usage if $opt_h;
 135
 136 my $podidx;
 137 if( $opt_X ) {
 138     $podidx = "$Config{'archlib'}/pod.idx";
 139     $podidx = "" unless -f $podidx && -r _ && -M _ <= 7;
 140 }
 141
 142 if( (my $opts = do{ local $^W; $opt_t + $opt_u + $opt_m + $opt_l }) > 1) {
 143     usage("only one of -t, -u, -m or -l")
 144 } elsif ($Is_MSWin32 || $Is_Dos) {
 145     $opt_t = 1 unless $opts
 146 }
 147
 148 if ($opt_t) { require Pod::Text; import Pod::Text; }
 149
 150 my @pages;
 151 if ($opt_f) {
 152    @pages = ("perlfunc");
 153 } elsif ($opt_q) {
 154    @pages = ("perlfaq1" .. "perlfaq9");
 155 } else {
 156    @pages = @ARGV;
 157 }
 158
 159 # Does this look like a module or extension directory?
 160 if (-f "Makefile.PL") {
 161         # Add ., lib and blib/* libs to @INC (if they exist)
 162         unshift(@INC, '.');
 163         unshift(@INC, 'lib') if -d 'lib';
 164         require ExtUtils::testlib;
 165 }
 166
 167
 168
 169 sub containspod {
 170     my($file, $readit) = @_;
 171     return 1 if !$readit && $file =~ /\.pod$/i;
 172     local($_);
 173     open(TEST,"<$file");
 174     while(<TEST>) {
 175         if(/^=head/) {
 176             close(TEST);
 177             return 1;
 178         }
 179     }
 180     close(TEST);
 181     return 0;
 182 }
 183
 184 sub minus_f_nocase {
 185      my($dir,$file) = @_;
 186      my $path = join('/',$dir,$file);
 187      return $path if -f $path and -r _;
 188      if (!$opt_i or $Is_VMS or $Is_MSWin32 or $Is_Dos or $^O eq 'os2') {
 189         # on a case-forgiving file system or if case is important
 190         # that is it all we can do
 191         warn "Ignored $path: unreadable\n" if -f _;
 192         return '';
 193      }
 194      local *DIR;
 195      local($")="/";
 196      my @p = ($dir);
 197      my($p,$cip);
 198      foreach $p (split(/\//, $file)){
 199         my $try = "@p/$p";
 200         stat $try;
 201         if (-d _){
 202             push @p, $p;
 203             if ( $p eq $global_target) {
 204                 my $tmp_path = join ('/', @p);
 205                 my $path_f = 0;
 206                 for (@global_found) {
 207                     $path_f = 1 if $_ eq $tmp_path;
 208                 }
 209                 push (@global_found, $tmp_path) unless $path_f;
 210                 print STDERR "Found as @p but directory\n" if $opt_v;
 211             }
 212         } elsif (-f _ && -r _) {
 213             return $try;
 214         } elsif (-f _) {
 215             warn "Ignored $try: unreadable\n";
 216         } else {
 217             my $found=0;
 218             my $lcp = lc $p;
 219             opendir DIR, "@p";
 220             while ($cip=readdir(DIR)) {
 221                 if (lc $cip eq $lcp){
 222                     $found++;
 223                     last;
 224                 }
 225             }
 226             closedir DIR;
 227             return "" unless $found;
 228             push @p, $cip;
 229             return "@p" if -f "@p" and -r _;
 230             warn "Ignored @p: unreadable\n" if -f _;
 231         }
 232      }
 233      return "";
 234 }
 235
 236
 237 sub check_file {
 238     my($dir,$file) = @_;
 239     if ($opt_m) {
 240         return minus_f_nocase($dir,$file);
 241     } else {
 242         my $path = minus_f_nocase($dir,$file);
 243         return $path if length $path and containspod($path);
 244     }
 245     return "";
 246 }
 247
 248
 249 sub searchfor {
 250     my($recurse,$s,@dirs) = @_;
 251     $s =~ s!::!/!g;
 252     $s = VMS::Filespec::unixify($s) if $Is_VMS;
 253     return $s if -f $s && containspod($s);
 254     printf STDERR "Looking for $s in @dirs\n" if $opt_v;
 255     my $ret;
 256     my $i;
 257     my $dir;
 258     $global_target = (split('/', $s))[-1];
 259     for ($i=0; $i<@dirs; $i++) {
 260         $dir = $dirs[$i];
 261         ($dir = VMS::Filespec::unixpath($dir)) =~ s!/$!! if $Is_VMS;
 262         if (       ( $ret = check_file $dir,"$s.pod")
 263                 or ( $ret = check_file $dir,"$s.pm")
 264                 or ( $ret = check_file $dir,$s)
 265                 or ( $Is_VMS and
 266                      $ret = check_file $dir,"$s.com")
 267                 or ( $^O eq 'os2' and
 268                      $ret = check_file $dir,"$s.cmd")
 269                 or ( ($Is_MSWin32 or $Is_Dos or $^O eq 'os2') and
 270                      $ret = check_file $dir,"$s.bat")
 271                 or ( $ret = check_file "$dir/pod","$s.pod")
 272                 or ( $ret = check_file "$dir/pod",$s)
 273         ) {
 274             return $ret;
 275         }
 276
 277         if ($recurse) {
 278             opendir(D,$dir);
 279             my @newdirs = map "$dir/$_", grep {
 280                 not /^\.\.?$/ and
 281                 not /^auto$/  and   # save time! don't search auto dirs
 282                 -d  "$dir/$_"
 283             } readdir D;
 284             closedir(D);
 285             next unless @newdirs;
 286             @newdirs = map((s/.dir$//,$_)[1],@newdirs) if $Is_VMS;
 287             print STDERR "Also looking in @newdirs\n" if $opt_v;
 288             push(@dirs,@newdirs);
 289         }
 290     }
 291     return ();
 292 }
 293
 294 sub filter_nroff {
 295   my @data = split /\n{2,}/, shift;
 296   shift @data while @data and $data[0] !~ /\S/; # Go to header
 297   shift @data if @data and $data[0] =~ /Contributed\s+Perl/; # Skip header
 298   pop @data if @data and $data[-1] =~ /^\w/; # Skip footer, like
 299                                 # 28/Jan/99 perl 5.005, patch 53 1
 300   join "\n\n", @data;
 301 }
 302
 303 my @found;
 304 foreach (@pages) {
 305         if ($podidx && open(PODIDX, $podidx)) {
 306             my $searchfor = $_;
 307             local($_);
 308             $searchfor =~ s,::,/,g;
 309             print STDERR "Searching for '$searchfor' in $podidx\n" if $opt_v;
 310             while (<PODIDX>) {
 311                 chomp;
 312                 push(@found, $_) if m,/$searchfor(?:\.(?:pod|pm))?$,i;
 313             }
 314             close(PODIDX);
 315             next;
 316         }
 317         print STDERR "Searching for $_\n" if $opt_v;
 318         # We must look both in @INC for library modules and in PATH
 319         # for executables, like h2xs or perldoc itself.
 320         my @searchdirs = @INC;
 321         if ($opt_F) {
 322           next unless -r;
 323           push @found, $_ if $opt_m or containspod($_);
 324           next;
 325         }
 326         unless ($opt_m) {
 327             if ($Is_VMS) {
 328                 my($i,$trn);
 329                 for ($i = 0; $trn = $ENV{'DCL$PATH;'.$i}; $i++) {
 330                     push(@searchdirs,$trn);
 331                 }
 332                 push(@searchdirs,'perl_root:[lib.pod]')  # installed pods
 333             } else {
 334                 push(@searchdirs, grep(-d, split($Config{path_sep},
 335                                                  $ENV{'PATH'})));
 336             }
 337         }
 338         my @files = searchfor(0,$_,@searchdirs);
 339         if( @files ) {
 340                 print STDERR "Found as @files\n" if $opt_v;
 341         } else {
 342                 # no match, try recursive search
 343
 344                 @searchdirs = grep(!/^\.$/,@INC);
 345
 346                 @files= searchfor(1,$_,@searchdirs) if $opt_r;
 347                 if( @files ) {
 348                         print STDERR "Loosely found as @files\n" if $opt_v;
 349                 } else {
 350                         print STDERR "No documentation found for \"$_\".\n";
 351                         if (@global_found) {
 352                             print STDERR "However, try\n";
 353                             for my $dir (@global_found) {
 354                                 opendir(DIR, $dir) or die "$!";
 355                                 while (my $file = readdir(DIR)) {
 356                                     next if ($file =~ /^\./);
 357                                     $file =~ s/\.(pm|pod)$//;
 358                                     print STDERR "\tperldoc $_\::$file\n";
 359                                 }
 360                                 closedir DIR;
 361                             }
 362                         }
 363                 }
 364         }
 365         push(@found,@files);
 366 }
 367
 368 if(!@found) {
 369         exit ($Is_VMS ? 98962 : 1);
 370 }
 371
 372 if ($opt_l) {
 373     print join("\n", @found), "\n";
 374     exit;
 375 }
 376
 377 my $lines = $ENV{LINES} || 24;
 378
 379 my $no_tty;
 380 if( ! -t STDOUT ) { $no_tty = 1 }
 381
 382 my $tmp;
 383 if ($Is_MSWin32) {
 384         $tmp = "$ENV{TEMP}\\perldoc1.$$";
 385         push @pagers, qw( more< less notepad );
 386         unshift @pagers, $ENV{PAGER}  if $ENV{PAGER};
 387 } elsif ($Is_VMS) {
 388         $tmp = 'Sys$Scratch:perldoc.tmp1_'.$$;
 389         push @pagers, qw( most more less type/page );
 390 } elsif ($Is_Dos) {
 391         $tmp = "$ENV{TEMP}/perldoc1.$$";
 392         $tmp =~ tr!\\/!//!s;
 393         push @pagers, qw( less.exe more.com< );
 394         unshift @pagers, $ENV{PAGER}  if $ENV{PAGER};
 395 } else {
 396         if ($^O eq 'os2') {
 397           require POSIX;
 398           $tmp = POSIX::tmpnam();
 399           unshift @pagers, 'less', 'cmd /c more <';
 400         } else {
 401           $tmp = "/tmp/perldoc1.$$";
 402         }
 403         push @pagers, qw( more less pg view cat );
 404         unshift @pagers, $ENV{PAGER}  if $ENV{PAGER};
 405 }
 406 unshift @pagers, $ENV{PERLDOC_PAGER} if $ENV{PERLDOC_PAGER};
 407
 408 if ($opt_m) {
 409         foreach my $pager (@pagers) {
 410                 system("$pager @found") or exit;
 411         }
 412         if ($Is_VMS) { eval 'use vmsish qw(status exit); exit $?' }
 413         exit 1;
 414 }
 415
 416 my @pod;
 417 if ($opt_f) {
 418    my $perlfunc = shift @found;
 419    open(PFUNC, $perlfunc) or die "Can't open $perlfunc: $!";
 420
 421    # Functions like -r, -e, etc. are listed under `-X'.
 422    my $search_string = ($opt_f =~ /^-[rwxoRWXOeszfdlpSbctugkTBMAC]$/) ? 'I<-X' : $opt_f ;
 423
 424    # Skip introduction
 425    while (<PFUNC>) {
 426        last if /^=head2 Alphabetical Listing of Perl Functions/;
 427    }
 428
 429    # Look for our function
 430    my $found = 0;
 431    while (<PFUNC>) {
 432        if (/^=item\s+\Q$search_string\E\b/o)  {
 433            $found = 1;
 434        } elsif (/^=item/) {
 435            last if $found > 1;
 436        }
 437        next unless $found;
 438        push @pod, $_;
 439        ++$found if /^\w/;       # found descriptive text
 440    }
 441    if (!@pod) {
 442        die "No documentation for perl function `$opt_f' found\n";
 443    }
 444 }
 445
 446 if ($opt_q) {
 447    local @ARGV = @found;        # I'm lazy, sue me.
 448    my $found = 0;
 449    my %found_in;
 450
 451    while (<>) {
 452       if (/^=head2\s+.*(?:$opt_q)/oi) {
 453          $found = 1;
 454          push @pod, "=head1 Found in $ARGV\n\n" unless $found_in{$ARGV}++;
 455       } elsif (/^=head2/) {
 456          $found = 0;
 457       }
 458       next unless $found;
 459       push @pod, $_;
 460    }
 461
 462    if (!@pod) {
 463       die "No documentation for perl FAQ keyword `$opt_q' found\n";
 464    }
 465 }
 466
 467 my $tmp1;
 468 my $filter;
 469
 470 if (@pod) {
 471   $tmp1 = $tmp . "_";
 472   open(TMP,">$tmp1") or die "open '$tmp1': $!";
 473   print TMP "=over 8\n\n";
 474   print TMP @pod;
 475   print TMP "=back\n";
 476   close(TMP) or die "close '$tmp1': $!";
 477   @found = $tmp1;
 478   $filter = 1;
 479 }
 480
 481 foreach (@found) {
 482
 483         my $err;
 484         if($opt_t) {
 485                 open(TMP,">>$tmp");
 486                 Pod::Text::pod2text($_,*TMP);
 487                 close(TMP);
 488         } elsif(not $opt_u) {
 489                 my $cmd = "pod2man --lax $_ | nroff -man";
 490                 $cmd .= " | col -x" if $^O =~ /hpux/;
 491                 my $rslt = `$cmd`;
 492                 $rslt = filter_nroff $rslt if $filter;
 493                 unless(($err = $?)) {
 494                         open(TMP,">>$tmp");
 495                         print TMP $rslt;
 496                         close TMP;
 497                 }
 498         }
 499
 500         if( $opt_u or $err or -z $tmp) {
 501                 open(OUT,">>$tmp");
 502                 open(IN,"<$_");
 503                 my $cut = 1;
 504                 while (<IN>) {
 505                         $cut = $1 eq 'cut' if /^=(\w+)/;
 506                         next if $cut;
 507                         print OUT;
 508                 }
 509                 close(IN);
 510                 close(OUT);
 511         }
 512 }
 513
 514 if( $no_tty ) {
 515         open(TMP,"<$tmp");
 516         print while <TMP>;
 517         close(TMP);
 518 } else {
 519         foreach my $pager (@pagers) {
 520                 system("$pager $tmp") or last;
 521         }
 522 }
 523
 524 1 while unlink($tmp); #Possibly pointless VMSism
 525 if (defined $tmp1) {
 526   1 while unlink($tmp1); #Possibly pointless VMSism
 527 }
 528
 529 exit 0;
 530
 531 __END__
 532
 533 =head1 NAME
 534
 535 perldoc - Look up Perl documentation in pod format.
 536
 537 =head1 SYNOPSIS
 538
 539 B<perldoc> [B<-h>] [B<-v>] [B<-t>] [B<-u>] [B<-m>] [B<-l>] [B<-F>]  [B<-X>] PageName|ModuleName|ProgramName
 540
 541 B<perldoc> B<-f> BuiltinFunction
 542
 543 B<perldoc> B<-q> FAQ Keyword
 544
 545 =head1 DESCRIPTION
 546
 547 I<perldoc> looks up a piece of documentation in .pod format that is embedded
 548 in the perl installation tree or in a perl script, and displays it via
 549 C<pod2man | nroff -man | $PAGER>. (In addition, if running under HP-UX,
 550 C<col -x> will be used.) This is primarily used for the documentation for
 551 the perl library modules.
 552
 553 Your system may also have man pages installed for those modules, in
 554 which case you can probably just use the man(1) command.
 555
 556 =head1 OPTIONS
 557
 558 =over 5
 559
 560 =item B<-h> help
 561
 562 Prints out a brief help message.
 563
 564 =item B<-v> verbose
 565
 566 Describes search for the item in detail.
 567
 568 =item B<-t> text output
 569
 570 Display docs using plain text converter, instead of nroff. This may be faster,
 571 but it won't look as nice.
 572
 573 =item B<-u> unformatted
 574
 575 Find docs only; skip reformatting by pod2*
 576
 577 =item B<-m> module
 578
 579 Display the entire module: both code and unformatted pod documentation.
 580 This may be useful if the docs don't explain a function in the detail
 581 you need, and you'd like to inspect the code directly; perldoc will find
 582 the file for you and simply hand it off for display.
 583
 584 =item B<-l> file name only
 585
 586 Display the file name of the module found.
 587
 588 =item B<-F> file names
 589
 590 Consider arguments as file names, no search in directories will be performed.
 591
 592 =item B<-f> perlfunc
 593
 594 The B<-f> option followed by the name of a perl built in function will
 595 extract the documentation of this function from L<perlfunc>.
 596
 597 =item B<-q> perlfaq
 598
 599 The B<-q> option takes a regular expression as an argument.  It will search
 600 the question headings in perlfaq[1-9] and print the entries matching
 601 the regular expression.
 602
 603 =item B<-X> use an index if present
 604
 605 The B<-X> option looks for a entry whose basename matches the name given on the
 606 command line in the file C<$Config{archlib}/pod.idx>.  The pod.idx file should
 607 contain fully qualified filenames, one per line.
 608
 609 =item B<PageName|ModuleName|ProgramName>
 610
 611 The item you want to look up.  Nested modules (such as C<File::Basename>)
 612 are specified either as C<File::Basename> or C<File/Basename>.  You may also
 613 give a descriptive name of a page, such as C<perlfunc>. You make also give a
 614 partial or wrong-case name, such as "basename" for "File::Basename", but
 615 this will be slower, if there is more then one page with the same partial
 616 name, you will only get the first one.
 617
 618 =back
 619
 620 =head1 ENVIRONMENT
 621
 622 Any switches in the C<PERLDOC> environment variable will be used before the
 623 command line arguments.  C<perldoc> also searches directories
 624 specified by the C<PERL5LIB> (or C<PERLLIB> if C<PERL5LIB> is not
 625 defined) and C<PATH> environment variables.
 626 (The latter is so that embedded pods for executables, such as
 627 C<perldoc> itself, are available.)  C<perldoc> will use, in order of
 628 preference, the pager defined in C<PERLDOC_PAGER>, C<MANPAGER>, or
 629 C<PAGER> before trying to find a pager on its own.  (C<MANPAGER> is not
 630 used if C<perldoc> was told to display plain text or unformatted pod.)
 631
 632 One useful value for C<PERLDOC_PAGER> is C<less -+C -E>.
 633
 634 =head1 AUTHOR
 635
 636 Kenneth Albanowski <kjahds@kjahds.com>
 637
 638 Minor updates by Andy Dougherty <doughera@lafcol.lafayette.edu>
 639
 640 =cut
 641
 642 #
 643 # Version 1.14: Wed Jul 15 01:50:20 EST 1998
 644 #       Robin Barker <rmb1@cise.npl.co.uk>
 645 #       -strict, -w cleanups
 646 # Version 1.13: Fri Feb 27 16:20:50 EST 1997
 647 #       Gurusamy Sarathy <gsar@umich.edu>
 648 #       -doc tweaks for -F and -X options
 649 # Version 1.12: Sat Apr 12 22:41:09 EST 1997
 650 #       Gurusamy Sarathy <gsar@umich.edu>
 651 #       -various fixes for win32
 652 # Version 1.11: Tue Dec 26 09:54:33 EST 1995
 653 #       Kenneth Albanowski <kjahds@kjahds.com>
 654 #   -added Charles Bailey's further VMS patches, and -u switch
 655 #   -added -t switch, with pod2text support
 656 #
 657 # Version 1.10: Thu Nov  9 07:23:47 EST 1995
 658 #               Kenneth Albanowski <kjahds@kjahds.com>
 659 #       -added VMS support
 660 #       -added better error recognition (on no found pages, just exit. On
 661 #        missing nroff/pod2man, just display raw pod.)
 662 #       -added recursive/case-insensitive matching (thanks, Andreas). This
 663 #        slows things down a bit, unfortunately. Give a precise name, and
 664 #        it'll run faster.
 665 #
 666 # Version 1.01: Tue May 30 14:47:34 EDT 1995
 667 #               Andy Dougherty  <doughera@lafcol.lafayette.edu>
 668 #   -added pod documentation.
 669 #   -added PATH searching.
 670 #   -added searching pod/ subdirectory (mainly to pick up perlfunc.pod
 671 #    and friends.
 672 #
 673 #
 674 # TODO:
 675 #
 676 #       Cache directories read during sloppy match
 677 !NO!SUBS!
 678
 679 close OUT or die "Can't close $file: $!";
 680 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
 681 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
 682 chdir $origdir;