[Summary view] [Print] [Text view]

   1  package ExtUtils::Manifest;
   2  
   3  require Exporter;
   4  use Config;
   5  use File::Basename;
   6  use File::Copy 'copy';
   7  use File::Find;
   8  use File::Spec;
   9  use Carp;
  10  use strict;
  11  
  12  use vars qw($VERSION @ISA @EXPORT_OK 
  13            $Is_MacOS $Is_VMS 
  14            $Debug $Verbose $Quiet $MANIFEST $DEFAULT_MSKIP);
  15  
  16  $VERSION = '1.51_01';
  17  @ISA=('Exporter');
  18  @EXPORT_OK = qw(mkmanifest
  19                  manicheck  filecheck  fullcheck  skipcheck
  20                  manifind   maniread   manicopy   maniadd
  21                 );
  22  
  23  $Is_MacOS = $^O eq 'MacOS';
  24  $Is_VMS   = $^O eq 'VMS';
  25  require VMS::Filespec if $Is_VMS;
  26  
  27  $Debug   = $ENV{PERL_MM_MANIFEST_DEBUG} || 0;
  28  $Verbose = defined $ENV{PERL_MM_MANIFEST_VERBOSE} ?
  29                     $ENV{PERL_MM_MANIFEST_VERBOSE} : 1;
  30  $Quiet = 0;
  31  $MANIFEST = 'MANIFEST';
  32  
  33  $DEFAULT_MSKIP = File::Spec->catfile( dirname(__FILE__), "$MANIFEST.SKIP" );
  34  
  35  
  36  =head1 NAME
  37  
  38  ExtUtils::Manifest - utilities to write and check a MANIFEST file
  39  
  40  =head1 SYNOPSIS
  41  
  42      use ExtUtils::Manifest qw(...funcs to import...);
  43  
  44      mkmanifest();
  45  
  46      my @missing_files    = manicheck;
  47      my @skipped          = skipcheck;
  48      my @extra_files      = filecheck;
  49      my($missing, $extra) = fullcheck;
  50  
  51      my $found    = manifind();
  52  
  53      my $manifest = maniread();
  54  
  55      manicopy($read,$target);
  56  
  57      maniadd({$file => $comment, ...});
  58  
  59  
  60  =head1 DESCRIPTION
  61  
  62  =head2 Functions
  63  
  64  ExtUtils::Manifest exports no functions by default.  The following are
  65  exported on request
  66  
  67  =over 4
  68  
  69  =item mkmanifest
  70  
  71      mkmanifest();
  72  
  73  Writes all files in and below the current directory to your F<MANIFEST>.
  74  It works similar to
  75  
  76      find . > MANIFEST
  77  
  78  All files that match any regular expression in a file F<MANIFEST.SKIP>
  79  (if it exists) are ignored.
  80  
  81  Any existing F<MANIFEST> file will be saved as F<MANIFEST.bak>.  Lines
  82  from the old F<MANIFEST> file is preserved, including any comments
  83  that are found in the existing F<MANIFEST> file in the new one.
  84  
  85  =cut
  86  
  87  sub _sort {
  88      return sort { lc $a cmp lc $b } @_;
  89  }
  90  
  91  sub mkmanifest {
  92      my $manimiss = 0;
  93      my $read = (-r 'MANIFEST' && maniread()) or $manimiss++;
  94      $read = {} if $manimiss;
  95      local *M;
  96      my $bakbase = $MANIFEST;
  97      $bakbase =~ s/\./_/g if $Is_VMS; # avoid double dots
  98      rename $MANIFEST, "$bakbase.bak" unless $manimiss;
  99      open M, ">$MANIFEST" or die "Could not open $MANIFEST: $!";
 100      my $skip = _maniskip();
 101      my $found = manifind();
 102      my($key,$val,$file,%all);
 103      %all = (%$found, %$read);
 104      $all{$MANIFEST} = ($Is_VMS ? "$MANIFEST\t\t" : '') . 'This list of files'
 105          if $manimiss; # add new MANIFEST to known file list
 106      foreach $file (_sort keys %all) {
 107      if ($skip->($file)) {
 108          # Policy: only remove files if they're listed in MANIFEST.SKIP.
 109          # Don't remove files just because they don't exist.
 110          warn "Removed from $MANIFEST: $file\n" if $Verbose and exists $read->{$file};
 111          next;
 112      }
 113      if ($Verbose){
 114          warn "Added to $MANIFEST: $file\n" unless exists $read->{$file};
 115      }
 116      my $text = $all{$file};
 117      $file = _unmacify($file);
 118      my $tabs = (5 - (length($file)+1)/8);
 119      $tabs = 1 if $tabs < 1;
 120      $tabs = 0 unless $text;
 121      print M $file, "\t" x $tabs, $text, "\n";
 122      }
 123      close M;
 124  }
 125  
 126  # Geez, shouldn't this use File::Spec or File::Basename or something?  
 127  # Why so careful about dependencies?
 128  sub clean_up_filename {
 129    my $filename = shift;
 130    $filename =~ s|^\./||;
 131    $filename =~ s/^:([^:]+)$/$1/ if $Is_MacOS;
 132    return $filename;
 133  }
 134  
 135  
 136  =item manifind
 137  
 138      my $found = manifind();
 139  
 140  returns a hash reference. The keys of the hash are the files found
 141  below the current directory.
 142  
 143  =cut
 144  
 145  sub manifind {
 146      my $p = shift || {};
 147      my $found = {};
 148  
 149      my $wanted = sub {
 150      my $name = clean_up_filename($File::Find::name);
 151      warn "Debug: diskfile $name\n" if $Debug;
 152      return if -d $_;
 153      
 154          if( $Is_VMS ) {
 155              $name =~ s#(.*)\.$#\L$1#;
 156              $name = uc($name) if $name =~ /^MANIFEST(\.SKIP)?$/i;
 157          }
 158      $found->{$name} = "";
 159      };
 160  
 161      # We have to use "$File::Find::dir/$_" in preprocess, because 
 162      # $File::Find::name is unavailable.
 163      # Also, it's okay to use / here, because MANIFEST files use Unix-style 
 164      # paths.
 165      find({wanted => $wanted},
 166       $Is_MacOS ? ":" : ".");
 167  
 168      return $found;
 169  }
 170  
 171  
 172  =item manicheck
 173  
 174      my @missing_files = manicheck();
 175  
 176  checks if all the files within a C<MANIFEST> in the current directory
 177  really do exist. If C<MANIFEST> and the tree below the current
 178  directory are in sync it silently returns an empty list.
 179  Otherwise it returns a list of files which are listed in the
 180  C<MANIFEST> but missing from the directory, and by default also
 181  outputs these names to STDERR.
 182  
 183  =cut
 184  
 185  sub manicheck {
 186      return _check_files();
 187  }
 188  
 189  
 190  =item filecheck
 191  
 192      my @extra_files = filecheck();
 193  
 194  finds files below the current directory that are not mentioned in the
 195  C<MANIFEST> file. An optional file C<MANIFEST.SKIP> will be
 196  consulted. Any file matching a regular expression in such a file will
 197  not be reported as missing in the C<MANIFEST> file. The list of any
 198  extraneous files found is returned, and by default also reported to
 199  STDERR.
 200  
 201  =cut
 202  
 203  sub filecheck {
 204      return _check_manifest();
 205  }
 206  
 207  
 208  =item fullcheck
 209  
 210      my($missing, $extra) = fullcheck();
 211  
 212  does both a manicheck() and a filecheck(), returning then as two array
 213  refs.
 214  
 215  =cut
 216  
 217  sub fullcheck {
 218      return [_check_files()], [_check_manifest()];
 219  }
 220  
 221  
 222  =item skipcheck
 223  
 224      my @skipped = skipcheck();
 225  
 226  lists all the files that are skipped due to your C<MANIFEST.SKIP>
 227  file.
 228  
 229  =cut
 230  
 231  sub skipcheck {
 232      my($p) = @_;
 233      my $found = manifind();
 234      my $matches = _maniskip();
 235  
 236      my @skipped = ();
 237      foreach my $file (_sort keys %$found){
 238          if (&$matches($file)){
 239              warn "Skipping $file\n";
 240              push @skipped, $file;
 241              next;
 242          }
 243      }
 244  
 245      return @skipped;
 246  }
 247  
 248  
 249  sub _check_files {
 250      my $p = shift;
 251      my $dosnames=(defined(&Dos::UseLFN) && Dos::UseLFN()==0);
 252      my $read = maniread() || {};
 253      my $found = manifind($p);
 254  
 255      my(@missfile) = ();
 256      foreach my $file (_sort keys %$read){
 257          warn "Debug: manicheck checking from $MANIFEST $file\n" if $Debug;
 258          if ($dosnames){
 259              $file = lc $file;
 260              $file =~ s=(\.(\w|-)+)=substr ($1,0,4)=ge;
 261              $file =~ s=((\w|-)+)=substr ($1,0,8)=ge;
 262          }
 263          unless ( exists $found->{$file} ) {
 264              warn "No such file: $file\n" unless $Quiet;
 265              push @missfile, $file;
 266          }
 267      }
 268  
 269      return @missfile;
 270  }
 271  
 272  
 273  sub _check_manifest {
 274      my($p) = @_;
 275      my $read = maniread() || {};
 276      my $found = manifind($p);
 277      my $skip  = _maniskip();
 278  
 279      my @missentry = ();
 280      foreach my $file (_sort keys %$found){
 281          next if $skip->($file);
 282          warn "Debug: manicheck checking from disk $file\n" if $Debug;
 283          unless ( exists $read->{$file} ) {
 284              my $canon = $Is_MacOS ? "\t" . _unmacify($file) : '';
 285              warn "Not in $MANIFEST: $file$canon\n" unless $Quiet;
 286              push @missentry, $file;
 287          }
 288      }
 289  
 290      return @missentry;
 291  }
 292  
 293  
 294  =item maniread
 295  
 296      my $manifest = maniread();
 297      my $manifest = maniread($manifest_file);
 298  
 299  reads a named C<MANIFEST> file (defaults to C<MANIFEST> in the current
 300  directory) and returns a HASH reference with files being the keys and
 301  comments being the values of the HASH.  Blank lines and lines which
 302  start with C<#> in the C<MANIFEST> file are discarded.
 303  
 304  =cut
 305  
 306  sub maniread {
 307      my ($mfile) = @_;
 308      $mfile ||= $MANIFEST;
 309      my $read = {};
 310      local *M;
 311      unless (open M, $mfile){
 312          warn "Problem opening $mfile: $!";
 313          return $read;
 314      }
 315      local $_;
 316      while (<M>){
 317          chomp;
 318          next if /^\s*#/;
 319  
 320          my($file, $comment) = /^(\S+)\s*(.*)/;
 321          next unless $file;
 322  
 323          if ($Is_MacOS) {
 324              $file = _macify($file);
 325              $file =~ s/\\([0-3][0-7][0-7])/sprintf("%c", oct($1))/ge;
 326          }
 327          elsif ($Is_VMS) {
 328              require File::Basename;
 329              my($base,$dir) = File::Basename::fileparse($file);
 330              # Resolve illegal file specifications in the same way as tar
 331              $dir =~ tr/./_/;
 332              my(@pieces) = split(/\./,$base);
 333              if (@pieces > 2) { $base = shift(@pieces) . '.' . join('_',@pieces); }
 334              my $okfile = "$dir$base";
 335              warn "Debug: Illegal name $file changed to $okfile\n" if $Debug;
 336              $file = $okfile;
 337              $file = lc($file) unless $file =~ /^MANIFEST(\.SKIP)?$/;
 338          }
 339  
 340          $read->{$file} = $comment;
 341      }
 342      close M;
 343      $read;
 344  }
 345  
 346  # returns an anonymous sub that decides if an argument matches
 347  sub _maniskip {
 348      my @skip ;
 349      my $mfile = "$MANIFEST.SKIP";
 350      _check_mskip_directives($mfile) if -f $mfile;
 351      local(*M, $_);
 352      open M, $mfile or open M, $DEFAULT_MSKIP or return sub {0};
 353      while (<M>){
 354      chomp;
 355      s/\r//;
 356      next if /^#/;
 357      next if /^\s*$/;
 358      push @skip, _macify($_);
 359      }
 360      close M;
 361      return sub {0} unless (scalar @skip > 0);
 362  
 363      my $opts = $Is_VMS ? '(?i)' : '';
 364  
 365      # Make sure each entry is isolated in its own parentheses, in case
 366      # any of them contain alternations
 367      my $regex = join '|', map "(?:$_)", @skip;
 368  
 369      return sub { $_[0] =~ qr{$opts$regex} };
 370  }
 371  
 372  # checks for the special directives
 373  #   #!include_default
 374  #   #!include /path/to/some/manifest.skip
 375  # in a custom MANIFEST.SKIP for, for including
 376  # the content of, respectively, the default MANIFEST.SKIP
 377  # and an external manifest.skip file
 378  sub _check_mskip_directives {
 379      my $mfile = shift;
 380      local (*M, $_);
 381      my @lines = ();
 382      my $flag = 0;
 383      unless (open M, $mfile) {
 384          warn "Problem opening $mfile: $!";
 385          return;
 386      }
 387      while (<M>) {
 388          if (/^#!include_default\s*$/) {
 389          if (my @default = _include_mskip_file()) {
 390              push @lines, @default;
 391          warn "Debug: Including default MANIFEST.SKIP\n" if $Debug;
 392          $flag++;
 393          }
 394          next;
 395          }
 396      if (/^#!include\s+(.*)\s*$/) {
 397          my $external_file = $1;
 398          if (my @external = _include_mskip_file($external_file)) {
 399              push @lines, @external;
 400          warn "Debug: Including external $external_file\n" if $Debug;
 401          $flag++;
 402          }
 403              next;
 404          }
 405          push @lines, $_;
 406      }
 407      close M;
 408      return unless $flag;
 409      my $bakbase = $mfile;
 410      $bakbase =~ s/\./_/g if $Is_VMS;  # avoid double dots
 411      rename $mfile, "$bakbase.bak";
 412      warn "Debug: Saving original $mfile as $bakbase.bak\n" if $Debug;
 413      unless (open M, ">$mfile") {
 414          warn "Problem opening $mfile: $!";
 415          return;
 416      }
 417      print M $_ for (@lines);
 418      close M;
 419      return;
 420  }
 421  
 422  # returns an array containing the lines of an external
 423  # manifest.skip file, if given, or $DEFAULT_MSKIP
 424  sub _include_mskip_file {
 425      my $mskip = shift || $DEFAULT_MSKIP;
 426      unless (-f $mskip) {
 427          warn qq{Included file "$mskip" not found - skipping};
 428          return;
 429      }
 430      local (*M, $_);
 431      unless (open M, $mskip) {
 432          warn "Problem opening $mskip: $!";
 433          return;
 434      }
 435      my @lines = ();
 436      push @lines, "\n#!start included $mskip\n";
 437      push @lines, $_ while <M>;
 438      close M;
 439      push @lines, "#!end included $mskip\n\n";
 440      return @lines;
 441  }
 442  
 443  =item manicopy
 444  
 445      manicopy(\%src, $dest_dir);
 446      manicopy(\%src, $dest_dir, $how);
 447  
 448  Copies the files that are the keys in %src to the $dest_dir.  %src is
 449  typically returned by the maniread() function.
 450  
 451      manicopy( maniread(), $dest_dir );
 452  
 453  This function is useful for producing a directory tree identical to the 
 454  intended distribution tree. 
 455  
 456  $how can be used to specify a different methods of "copying".  Valid
 457  values are C<cp>, which actually copies the files, C<ln> which creates
 458  hard links, and C<best> which mostly links the files but copies any
 459  symbolic link to make a tree without any symbolic link.  C<cp> is the 
 460  default.
 461  
 462  =cut
 463  
 464  sub manicopy {
 465      my($read,$target,$how)=@_;
 466      croak "manicopy() called without target argument" unless defined $target;
 467      $how ||= 'cp';
 468      require File::Path;
 469      require File::Basename;
 470  
 471      $target = VMS::Filespec::unixify($target) if $Is_VMS;
 472      File::Path::mkpath([ $target ],! $Quiet,$Is_VMS ? undef : 0755);
 473      foreach my $file (keys %$read){
 474          if ($Is_MacOS) {
 475          if ($file =~ m!:!) { 
 476             my $dir = _maccat($target, $file);
 477          $dir =~ s/[^:]+$//;
 478              File::Path::mkpath($dir,1,0755);
 479          }
 480          cp_if_diff($file, _maccat($target, $file), $how);
 481      } else {
 482          $file = VMS::Filespec::unixify($file) if $Is_VMS;
 483          if ($file =~ m!/!) { # Ilya, that hurts, I fear, or maybe not?
 484          my $dir = File::Basename::dirname($file);
 485          $dir = VMS::Filespec::unixify($dir) if $Is_VMS;
 486          File::Path::mkpath(["$target/$dir"],! $Quiet,$Is_VMS ? undef : 0755);
 487          }
 488          cp_if_diff($file, "$target/$file", $how);
 489      }
 490      }
 491  }
 492  
 493  sub cp_if_diff {
 494      my($from, $to, $how)=@_;
 495      -f $from or carp "$0: $from not found";
 496      my($diff) = 0;
 497      local(*F,*T);
 498      open(F,"< $from\0") or die "Can't read $from: $!\n";
 499      if (open(T,"< $to\0")) {
 500          local $_;
 501      while (<F>) { $diff++,last if $_ ne <T>; }
 502      $diff++ unless eof(T);
 503      close T;
 504      }
 505      else { $diff++; }
 506      close F;
 507      if ($diff) {
 508      if (-e $to) {
 509          unlink($to) or confess "unlink $to: $!";
 510      }
 511          STRICT_SWITCH: {
 512          best($from,$to), last STRICT_SWITCH if $how eq 'best';
 513          cp($from,$to), last STRICT_SWITCH if $how eq 'cp';
 514          ln($from,$to), last STRICT_SWITCH if $how eq 'ln';
 515          croak("ExtUtils::Manifest::cp_if_diff " .
 516            "called with illegal how argument [$how]. " .
 517            "Legal values are 'best', 'cp', and 'ln'.");
 518      }
 519      }
 520  }
 521  
 522  sub cp {
 523      my ($srcFile, $dstFile) = @_;
 524      my ($access,$mod) = (stat $srcFile)[8,9];
 525  
 526      copy($srcFile,$dstFile);
 527      utime $access, $mod + ($Is_VMS ? 1 : 0), $dstFile;
 528      _manicopy_chmod($srcFile, $dstFile);
 529  }
 530  
 531  
 532  sub ln {
 533      my ($srcFile, $dstFile) = @_;
 534      return &cp if $Is_VMS or ($^O eq 'MSWin32' and Win32::IsWin95());
 535      link($srcFile, $dstFile);
 536  
 537      unless( _manicopy_chmod($srcFile, $dstFile) ) {
 538          unlink $dstFile;
 539          return;
 540      }
 541      1;
 542  }
 543  
 544  # 1) Strip off all group and world permissions.
 545  # 2) Let everyone read it.
 546  # 3) If the owner can execute it, everyone can.
 547  sub _manicopy_chmod {
 548      my($srcFile, $dstFile) = @_;
 549  
 550      my $perm = 0444 | (stat $srcFile)[2] & 0700;
 551      chmod( $perm | ( $perm & 0100 ? 0111 : 0 ), $dstFile );
 552  }
 553  
 554  # Files that are often modified in the distdir.  Don't hard link them.
 555  my @Exceptions = qw(MANIFEST META.yml SIGNATURE);
 556  sub best {
 557      my ($srcFile, $dstFile) = @_;
 558  
 559      my $is_exception = grep $srcFile =~ /$_/, @Exceptions;
 560      if ($is_exception or !$Config{d_link} or -l $srcFile) {
 561      cp($srcFile, $dstFile);
 562      } else {
 563      ln($srcFile, $dstFile) or cp($srcFile, $dstFile);
 564      }
 565  }
 566  
 567  sub _macify {
 568      my($file) = @_;
 569  
 570      return $file unless $Is_MacOS;
 571  
 572      $file =~ s|^\./||;
 573      if ($file =~ m|/|) {
 574      $file =~ s|/+|:|g;
 575      $file = ":$file";
 576      }
 577  
 578      $file;
 579  }
 580  
 581  sub _maccat {
 582      my($f1, $f2) = @_;
 583  
 584      return "$f1/$f2" unless $Is_MacOS;
 585  
 586      $f1 .= ":$f2";
 587      $f1 =~ s/([^:]:):/$1/g;
 588      return $f1;
 589  }
 590  
 591  sub _unmacify {
 592      my($file) = @_;
 593  
 594      return $file unless $Is_MacOS;
 595  
 596      $file =~ s|^:||;
 597      $file =~ s|([/ \n])|sprintf("\\%03o", unpack("c", $1))|ge;
 598      $file =~ y|:|/|;
 599  
 600      $file;
 601  }
 602  
 603  
 604  =item maniadd
 605  
 606    maniadd({ $file => $comment, ...});
 607  
 608  Adds an entry to an existing F<MANIFEST> unless its already there.
 609  
 610  $file will be normalized (ie. Unixified).  B<UNIMPLEMENTED>
 611  
 612  =cut
 613  
 614  sub maniadd {
 615      my($additions) = shift;
 616  
 617      _normalize($additions);
 618      _fix_manifest($MANIFEST);
 619  
 620      my $manifest = maniread();
 621      my @needed = grep { !exists $manifest->{$_} } keys %$additions;
 622      return 1 unless @needed;
 623  
 624      open(MANIFEST, ">>$MANIFEST") or 
 625        die "maniadd() could not open $MANIFEST: $!";
 626  
 627      foreach my $file (_sort @needed) {
 628          my $comment = $additions->{$file} || '';
 629          printf MANIFEST "%-40s %s\n", $file, $comment;
 630      }
 631      close MANIFEST or die "Error closing $MANIFEST: $!";
 632  
 633      return 1;
 634  }
 635  
 636  
 637  # Sometimes MANIFESTs are missing a trailing newline.  Fix this.
 638  sub _fix_manifest {
 639      my $manifest_file = shift;
 640  
 641      open MANIFEST, $MANIFEST or die "Could not open $MANIFEST: $!";
 642  
 643      # Yes, we should be using seek(), but I'd like to avoid loading POSIX
 644      # to get SEEK_*
 645      my @manifest = <MANIFEST>;
 646      close MANIFEST;
 647  
 648      unless( $manifest[-1] =~ /\n\z/ ) {
 649          open MANIFEST, ">>$MANIFEST" or die "Could not open $MANIFEST: $!";
 650          print MANIFEST "\n";
 651          close MANIFEST;
 652      }
 653  }
 654  
 655  
 656  # UNIMPLEMENTED
 657  sub _normalize {
 658      return;
 659  }
 660  
 661  
 662  =back
 663  
 664  =head2 MANIFEST
 665  
 666  A list of files in the distribution, one file per line.  The MANIFEST
 667  always uses Unix filepath conventions even if you're not on Unix.  This
 668  means F<foo/bar> style not F<foo\bar>.
 669  
 670  Anything between white space and an end of line within a C<MANIFEST>
 671  file is considered to be a comment.  Any line beginning with # is also
 672  a comment.
 673  
 674      # this a comment
 675      some/file
 676      some/other/file            comment about some/file
 677  
 678  
 679  =head2 MANIFEST.SKIP
 680  
 681  The file MANIFEST.SKIP may contain regular expressions of files that
 682  should be ignored by mkmanifest() and filecheck(). The regular
 683  expressions should appear one on each line. Blank lines and lines
 684  which start with C<#> are skipped.  Use C<\#> if you need a regular
 685  expression to start with a C<#>.
 686  
 687  For example:
 688  
 689      # Version control files and dirs.
 690      \bRCS\b
 691      \bCVS\b
 692      ,v$
 693      \B\.svn\b
 694  
 695      # Makemaker generated files and dirs.
 696      ^MANIFEST\.
 697      ^Makefile$
 698      ^blib/
 699      ^MakeMaker-\d
 700  
 701      # Temp, old and emacs backup files.
 702      ~$
 703      \.old$
 704      ^#.*#$
 705      ^\.#
 706  
 707  If no MANIFEST.SKIP file is found, a default set of skips will be
 708  used, similar to the example above.  If you want nothing skipped,
 709  simply make an empty MANIFEST.SKIP file.
 710  
 711  In one's own MANIFEST.SKIP file, certain directives
 712  can be used to include the contents of other MANIFEST.SKIP
 713  files. At present two such directives are recognized.
 714  
 715  =over 4
 716  
 717  =item #!include_default
 718  
 719  This inserts the contents of the default MANIFEST.SKIP file
 720  
 721  =item #!include /Path/to/another/manifest.skip
 722  
 723  This inserts the contents of the specified external file
 724  
 725  =back
 726  
 727  The included contents will be inserted into the MANIFEST.SKIP
 728  file in between I<#!start included /path/to/manifest.skip>
 729  and I<#!end included /path/to/manifest.skip> markers.
 730  The original MANIFEST.SKIP is saved as MANIFEST.SKIP.bak.
 731  
 732  =head2 EXPORT_OK
 733  
 734  C<&mkmanifest>, C<&manicheck>, C<&filecheck>, C<&fullcheck>,
 735  C<&maniread>, and C<&manicopy> are exportable.
 736  
 737  =head2 GLOBAL VARIABLES
 738  
 739  C<$ExtUtils::Manifest::MANIFEST> defaults to C<MANIFEST>. Changing it
 740  results in both a different C<MANIFEST> and a different
 741  C<MANIFEST.SKIP> file. This is useful if you want to maintain
 742  different distributions for different audiences (say a user version
 743  and a developer version including RCS).
 744  
 745  C<$ExtUtils::Manifest::Quiet> defaults to 0. If set to a true value,
 746  all functions act silently.
 747  
 748  C<$ExtUtils::Manifest::Debug> defaults to 0.  If set to a true value,
 749  or if PERL_MM_MANIFEST_DEBUG is true, debugging output will be
 750  produced.
 751  
 752  =head1 DIAGNOSTICS
 753  
 754  All diagnostic output is sent to C<STDERR>.
 755  
 756  =over 4
 757  
 758  =item C<Not in MANIFEST:> I<file>
 759  
 760  is reported if a file is found which is not in C<MANIFEST>.
 761  
 762  =item C<Skipping> I<file>
 763  
 764  is reported if a file is skipped due to an entry in C<MANIFEST.SKIP>.
 765  
 766  =item C<No such file:> I<file>
 767  
 768  is reported if a file mentioned in a C<MANIFEST> file does not
 769  exist.
 770  
 771  =item C<MANIFEST:> I<$!>
 772  
 773  is reported if C<MANIFEST> could not be opened.
 774  
 775  =item C<Added to MANIFEST:> I<file>
 776  
 777  is reported by mkmanifest() if $Verbose is set and a file is added
 778  to MANIFEST. $Verbose is set to 1 by default.
 779  
 780  =back
 781  
 782  =head1 ENVIRONMENT
 783  
 784  =over 4
 785  
 786  =item B<PERL_MM_MANIFEST_DEBUG>
 787  
 788  Turns on debugging
 789  
 790  =back
 791  
 792  =head1 SEE ALSO
 793  
 794  L<ExtUtils::MakeMaker> which has handy targets for most of the functionality.
 795  
 796  =head1 AUTHOR
 797  
 798  Andreas Koenig C<andreas.koenig@anima.de>
 799  
 800  Maintained by Michael G Schwern C<schwern@pobox.com> within the
 801  ExtUtils-MakeMaker package and, as a separate CPAN package, by
 802  Randy Kobes C<r.kobes@uwinnipeg.ca>.
 803  
 804  =cut
 805  
 806  1;