[p5sagit/p5-mst-13.2.git] / lib / ExtUtils / Manifest.pm

package ExtUtils::Manifest;

require Exporter;
use Config;
use File::Find;
use File::Copy 'copy';
use Carp;
use strict;

use vars qw(@ISA @EXPORT_OK $VERSION $Debug $Verbose $Is_VMS $Quiet $MANIFEST $found);

@ISA=('Exporter');
@EXPORT_OK = ('mkmanifest', 'manicheck', 'fullcheck', 'filecheck', 
	      'skipcheck', 'maniread', 'manicopy');

$Debug = 0;
$Verbose = 1;
$Is_VMS = $^O eq 'VMS';

$VERSION = substr(q$Revision: 1.27 $,10,4);

$Quiet = 0;

$MANIFEST = 'MANIFEST';

# Really cool fix from Ilya :)
unless (defined $Config{d_link}) {
    local($^W) = 0;  # avoid sub redefined message
    *ln = \&cp;
}

sub mkmanifest {
    my $manimiss = 0;
    my $read = maniread() or $manimiss++;
    $read = {} if $manimiss;
    local *M;
    rename $MANIFEST, "$MANIFEST.bak" unless $manimiss;
    open M, ">$MANIFEST" or die "Could not open $MANIFEST: $!";
    my $matches = _maniskip();
    my $found = manifind();
    my($key,$val,$file,%all);
    %all = (%$found, %$read);
    $all{$MANIFEST} = ($Is_VMS ? "$MANIFEST\t\t" : '') . 'This list of files'
        if $manimiss; # add new MANIFEST to known file list
    foreach $file (sort keys %all) {
	next if &$matches($file);
	if ($Verbose){
	    warn "Added to $MANIFEST: $file\n" unless exists $read->{$file};
	}
	my $text = $all{$file};
	($file,$text) = split(/\s+/,$text,2) if $Is_VMS && $text;
	my $tabs = (5 - (length($file)+1)/8);
	$tabs = 1 if $tabs < 1;
	$tabs = 0 unless $text;
	print M $file, "\t" x $tabs, $text, "\n";
    }
    close M;
}

sub manifind {
    local $found = {};
    find(sub {return if -d $_;
	      (my $name = $File::Find::name) =~ s|./||;
	      warn "Debug: diskfile $name\n" if $Debug;
	      $name  =~ s#(.*)\.$#\L$1# if $Is_VMS;
	      $found->{$name} = "";}, ".");
    $found;
}

sub fullcheck {
    _manicheck(3);
}

sub manicheck {
    return @{(_manicheck(1))[0]};
}

sub filecheck {
    return @{(_manicheck(2))[1]};
}

sub skipcheck {
    _manicheck(6);
}

sub _manicheck {
    my($arg) = @_;
    my $read = maniread();
    my $file;
    my(@missfile,@missentry);
    if ($arg & 1){
	my $found = manifind();
	foreach $file (sort keys %$read){
	    warn "Debug: manicheck checking from $MANIFEST $file\n" if $Debug;
	    unless ( exists $found->{$file} ) {
		warn "No such file: $file\n" unless $Quiet;
		push @missfile, $file;
	    }
	}
    }
    if ($arg & 2){
	$read ||= {};
	my $matches = _maniskip();
	my $found = manifind();
	my $skipwarn = $arg & 4;
	foreach $file (sort keys %$found){
	    if (&$matches($file)){
		warn "Skipping $file\n" if $skipwarn;
		next;
	    }
	    warn "Debug: manicheck checking from disk $file\n" if $Debug;
	    unless ( exists $read->{$file} ) {
		warn "Not in $MANIFEST: $file\n" unless $Quiet;
		push @missentry, $file;
	    }
	}
    }
    (\@missfile,\@missentry);
}

sub maniread {
    my ($mfile) = @_;
    $mfile = $MANIFEST unless defined $mfile;
    my $read = {};
    local *M;
    unless (open M, $mfile){
	warn "$mfile: $!";
	return $read;
    }
    while (<M>){
	chomp;
	if ($Is_VMS) { /^(\S+)/ and $read->{"\L$1"}=$_; }
	else         { /^(\S+)\s*(.*)/ and $read->{$1}=$2; }
    }
    close M;
    $read;
}

# returns an anonymous sub that decides if an argument matches
sub _maniskip {
    my ($mfile) = @_;
    my $matches = sub {0};
    my @skip ;
    $mfile = "$MANIFEST.SKIP" unless defined $mfile;
    local *M;
    return $matches unless -f $mfile;
    open M, $mfile or return $matches;
    while (<M>){
	chomp;
	next if /^\s*$/;
	push @skip, $_;
    }
    close M;
    my $opts = $Is_VMS ? 'oi ' : 'o ';
    my $sub = "\$matches = "
	. "sub { my(\$arg)=\@_; return 1 if "
	. join (" || ",  (map {s!/!\\/!g; "\$arg =~ m/$_/$opts"} @skip), 0)
	. " }";
    eval $sub;
    print "Debug: $sub\n" if $Debug;
    $matches;
}

sub manicopy {
    my($read,$target,$how)=@_;
    croak "manicopy() called without target argument" unless defined $target;
    $how = 'cp' unless defined $how && $how;
    require File::Path;
    require File::Basename;
    my(%dirs,$file);
    $target = VMS::Filespec::unixify($target) if $Is_VMS;
    umask 0 unless $Is_VMS;
    File::Path::mkpath([ $target ],1,$Is_VMS ? undef : 0755);
    foreach $file (keys %$read){
	$file = VMS::Filespec::unixify($file) if $Is_VMS;
	if ($file =~ m!/!) { # Ilya, that hurts, I fear, or maybe not?
	    my $dir = File::Basename::dirname($file);
	    $dir = VMS::Filespec::unixify($dir) if $Is_VMS;
	    File::Path::mkpath(["$target/$dir"],1,$Is_VMS ? undef : 0755);
	}
	if ($Is_VMS) { vms_cp_if_diff($file,"$target/$file"); }
	else         { cp_if_diff($file, "$target/$file", $how); }
    }
}

sub cp_if_diff {
    my($from, $to, $how)=@_;
    -f $from || carp "$0: $from not found";
    my($diff) = 0;
    local(*F,*T);
    open(F,$from) or croak "Can't read $from: $!\n";
    if (open(T,$to)) {
	while (<F>) { $diff++,last if $_ ne <T>; }
	$diff++ unless eof(T);
	close T;
    }
    else { $diff++; }
    close F;
    if ($diff) {
	if (-e $to) {
	    unlink($to) or confess "unlink $to: $!";
	}
	STRICT_SWITCH: {
	      best($from,$to), last STRICT_SWITCH if $how eq 'best';
	        cp($from,$to), last STRICT_SWITCH if $how eq 'cp';
	        ln($from,$to), last STRICT_SWITCH if $how eq 'ln';
	  }
    }
}

# Do the comparisons here rather than spawning off another process
sub vms_cp_if_diff {
    my($from,$to) = @_;
    my($diff) = 0;
    local(*F,*T);
    open(F,$from) or croak "Can't read $from: $!\n";
    if (open(T,$to)) {
	while (<F>) { $diff++,last if $_ ne <T>; }
	$diff++ unless eof(T);
	close T;
    }
    else { $diff++; }
    close F;
    if ($diff) {
	system('copy',VMS::Filespec::vmsify($from),VMS::Filespec::vmsify($to)) & 1
	    or confess "Copy failed: $!";
    }
}

sub cp {
    my ($srcFile, $dstFile) = @_;
    my ($perm,$access,$mod) = (stat $srcFile)[2,8,9];
    copy($srcFile,$dstFile);
    utime $access, $mod, $dstFile;
    # chmod a+rX-w,go-w
    chmod(  0444 | ( $perm & 0111 ? 0111 : 0 ),  $dstFile );
}

sub ln {
    my ($srcFile, $dstFile) = @_;
    link($srcFile, $dstFile);
    local($_) = $dstFile; # chmod a+r,go-w+X (except "X" only applies to u=x)
    my $mode= 0444 | (stat)[2] & 0700;
    chmod(  $mode | ( $mode & 0100 ? 0111 : 0 ),  $_  );
}

sub best {
    my ($srcFile, $dstFile) = @_;
    if (-l $srcFile) {
	cp($srcFile, $dstFile);
    } else {
	ln($srcFile, $dstFile);
    }
}

1;

__END__

=head1 NAME

ExtUtils::Manifest - utilities to write and check a MANIFEST file

=head1 SYNOPSIS

C<require ExtUtils::Manifest;>

C<ExtUtils::Manifest::mkmanifest;>

C<ExtUtils::Manifest::manicheck;>

C<ExtUtils::Manifest::filecheck;>

C<ExtUtils::Manifest::fullcheck;>

C<ExtUtils::Manifest::skipcheck;>

C<ExtUtild::Manifest::manifind();>

C<ExtUtils::Manifest::maniread($file);>

C<ExtUtils::Manifest::manicopy($read,$target,$how);>

=head1 DESCRIPTION

Mkmanifest() writes all files in and below the current directory to a
file named in the global variable $ExtUtils::Manifest::MANIFEST (which
defaults to C<MANIFEST>) in the current directory. It works similar to

    find . -print

but in doing so checks each line in an existing C<MANIFEST> file and
includes any comments that are found in the existing C<MANIFEST> file
in the new one. Anything between white space and an end of line within
a C<MANIFEST> file is considered to be a comment. Filenames and
comments are seperated by one or more TAB characters in the
output. All files that match any regular expression in a file
C<MANIFEST.SKIP> (if such a file exists) are ignored.

Manicheck() checks if all the files within a C<MANIFEST> in the
current directory really do exist. It only reports discrepancies and
exits silently if MANIFEST and the tree below the current directory
are in sync.

Filecheck() finds files below the current directory that are not
mentioned in the C<MANIFEST> file. An optional file C<MANIFEST.SKIP>
will be consulted. Any file matching a regular expression in such a
file will not be reported as missing in the C<MANIFEST> file.

Fullcheck() does both a manicheck() and a filecheck().

Skipcheck() lists all the files that are skipped due to your
C<MANIFEST.SKIP> file.

Manifind() retruns a hash reference. The keys of the hash are the
files found below the current directory.

Maniread($file) reads a named C<MANIFEST> file (defaults to
C<MANIFEST> in the current directory) and returns a HASH reference
with files being the keys and comments being the values of the HASH.

I<Manicopy($read,$target,$how)> copies the files that are the keys in
the HASH I<%$read> to the named target directory. The HASH reference
I<$read> is typically returned by the maniread() function. This
function is useful for producing a directory tree identical to the
intended distribution tree. The third parameter $how can be used to
specify a different methods of "copying". Valid values are C<cp>,
which actually copies the files, C<ln> which creates hard links, and
C<best> which mostly links the files but copies any symbolic link to
make a tree without any symbolic link. Best is the default.

=head1 MANIFEST.SKIP

The file MANIFEST.SKIP may contain regular expressions of files that
should be ignored by mkmanifest() and filecheck(). The regular
expressions should appear one on each line. A typical example:

    \bRCS\b
    ^MANIFEST\.
    ^Makefile$
    ~$
    \.html$
    \.old$
    ^blib/
    ^MakeMaker-\d

=head1 EXPORT_OK

C<&mkmanifest>, C<&manicheck>, C<&filecheck>, C<&fullcheck>,
C<&maniread>, and C<&manicopy> are exportable.

=head1 GLOBAL VARIABLES

C<$ExtUtils::Manifest::MANIFEST> defaults to C<MANIFEST>. Changing it
results in both a different C<MANIFEST> and a different
C<MANIFEST.SKIP> file. This is useful if you want to maintain
different distributions for different audiences (say a user version
and a developer version including RCS).

C<$ExtUtils::Manifest::Quiet> defaults to 0. If set to a true value,
all functions act silently.

=head1 DIAGNOSTICS

All diagnostic output is sent to C<STDERR>.

=over

=item C<Not in MANIFEST:> I<file>

is reported if a file is found, that is missing in the C<MANIFEST>
file which is excluded by a regular expression in the file
C<MANIFEST.SKIP>.

=item C<No such file:> I<file>

is reported if a file mentioned in a C<MANIFEST> file does not
exist.

=item C<MANIFEST:> I<$!>

is reported if C<MANIFEST> could not be opened.

=item C<Added to MANIFEST:> I<file>

is reported by mkmanifest() if $Verbose is set and a file is added
to MANIFEST. $Verbose is set to 1 by default.

=back

=head1 SEE ALSO

L<ExtUtils::MakeMaker> which has handy targets for most of the functionality.

=head1 AUTHOR

Andreas Koenig E<lt>F<koenig@franz.ww.TU-Berlin.DE>E<gt>

=cut
Commit	Line	Data
005c1a0e	1	package ExtUtils::Manifest;
005c1a0e	2
005c1a0e	3	require Exporter;
8e07c86e	4	use Config;
005c1a0e	5	use File::Find;
79dd614e	6	use File::Copy 'copy';
005c1a0e	7	use Carp;
8a1da95f	8	use strict;
	9
	10	use vars qw(@ISA @EXPORT_OK $VERSION $Debug $Verbose $Is_VMS $Quiet $MANIFEST $found);
	11
	12	@ISA=('Exporter');
	13	@EXPORT_OK = ('mkmanifest', 'manicheck', 'fullcheck', 'filecheck',
	14	'skipcheck', 'maniread', 'manicopy');
005c1a0e	15
	16	$Debug = 0;
	17	$Verbose = 1;
79dd614e	18	$Is_VMS = $^O eq 'VMS';
005c1a0e	19
8a1da95f	20	$VERSION = substr(q$Revision: 1.27 $,10,4);
005c1a0e	21
	22	$Quiet = 0;
	23
cb1a09d0	24	$MANIFEST = 'MANIFEST';
cb1a09d0	25
4e68a208	26	# Really cool fix from Ilya :)
4e68a208	27	unless (defined $Config{d_link}) {
81ff29e3	28	local($^W) = 0; # avoid sub redefined message
4e68a208	29	*ln = \&cp;
	30	}
	31
005c1a0e	32	sub mkmanifest {
	33	my $manimiss = 0;
	34	my $read = maniread() or $manimiss++;
	35	$read = {} if $manimiss;
864a5fa8	36	local *M;
cb1a09d0	37	rename $MANIFEST, "$MANIFEST.bak" unless $manimiss;
cb1a09d0	38	open M, ">$MANIFEST" or die "Could not open $MANIFEST: $!";
005c1a0e	39	my $matches = _maniskip();
	40	my $found = manifind();
	41	my($key,$val,$file,%all);
f1387719	42	%all = (%$found, %$read);
84876ac5	43	$all{$MANIFEST} = ($Is_VMS ? "$MANIFEST\t\t" : '') . 'This list of files'
84876ac5	44	if $manimiss; # add new MANIFEST to known file list
005c1a0e	45	foreach $file (sort keys %all) {
	46	next if &$matches($file);
	47	if ($Verbose){
cb1a09d0	48	warn "Added to $MANIFEST: $file\n" unless exists $read->{$file};
005c1a0e	49	}
8e07c86e	50	my $text = $all{$file};
84876ac5	51	($file,$text) = split(/\s+/,$text,2) if $Is_VMS && $text;
005c1a0e	52	my $tabs = (5 - (length($file)+1)/8);
005c1a0e	53	$tabs = 1 if $tabs < 1;
8e07c86e	54	$tabs = 0 unless $text;
8e07c86e	55	print M $file, "\t" x $tabs, $text, "\n";
005c1a0e	56	}
	57	close M;
	58	}
	59
	60	sub manifind {
	61	local $found = {};
4633a7c4	62	find(sub {return if -d $_;
005c1a0e	63	(my $name = $File::Find::name) =~ s\|./\|\|;
005c1a0e	64	warn "Debug: diskfile $name\n" if $Debug;
8e07c86e	65	$name =~ s#(.*)\.$#\L$1# if $Is_VMS;
005c1a0e	66	$found->{$name} = "";}, ".");
	67	$found;
	68	}
	69
	70	sub fullcheck {
	71	_manicheck(3);
	72	}
	73
	74	sub manicheck {
	75	return @{(_manicheck(1))[0]};
	76	}
	77
	78	sub filecheck {
	79	return @{(_manicheck(2))[1]};
	80	}
	81
8e07c86e	82	sub skipcheck {
	83	_manicheck(6);
	84	}
	85
005c1a0e	86	sub _manicheck {
	87	my($arg) = @_;
	88	my $read = maniread();
	89	my $file;
	90	my(@missfile,@missentry);
	91	if ($arg & 1){
	92	my $found = manifind();
	93	foreach $file (sort keys %$read){
cb1a09d0	94	warn "Debug: manicheck checking from $MANIFEST $file\n" if $Debug;
005c1a0e	95	unless ( exists $found->{$file} ) {
8e07c86e	96	warn "No such file: $file\n" unless $Quiet;
8e07c86e	97	push @missfile, $file;
005c1a0e	98	}
	99	}
	100	}
	101	if ($arg & 2){
	102	$read \|\|= {};
	103	my $matches = _maniskip();
	104	my $found = manifind();
8e07c86e	105	my $skipwarn = $arg & 4;
005c1a0e	106	foreach $file (sort keys %$found){
8e07c86e	107	if (&$matches($file)){
	108	warn "Skipping $file\n" if $skipwarn;
	109	next;
	110	}
005c1a0e	111	warn "Debug: manicheck checking from disk $file\n" if $Debug;
005c1a0e	112	unless ( exists $read->{$file} ) {
cb1a09d0	113	warn "Not in $MANIFEST: $file\n" unless $Quiet;
8e07c86e	114	push @missentry, $file;
005c1a0e	115	}
	116	}
	117	}
	118	(\@missfile,\@missentry);
	119	}
	120
	121	sub maniread {
	122	my ($mfile) = @_;
cb1a09d0	123	$mfile = $MANIFEST unless defined $mfile;
005c1a0e	124	my $read = {};
	125	local *M;
	126	unless (open M, $mfile){
	127	warn "$mfile: $!";
	128	return $read;
	129	}
	130	while (<M>){
	131	chomp;
8e07c86e	132	if ($Is_VMS) { /^(\S+)/ and $read->{"\L$1"}=$_; }
8e07c86e	133	else { /^(\S+)\s(.)/ and $read->{$1}=$2; }
005c1a0e	134	}
	135	close M;
	136	$read;
	137	}
	138
	139	# returns an anonymous sub that decides if an argument matches
	140	sub _maniskip {
	141	my ($mfile) = @_;
	142	my $matches = sub {0};
	143	my @skip ;
f1387719	144	$mfile = "$MANIFEST.SKIP" unless defined $mfile;
005c1a0e	145	local *M;
	146	return $matches unless -f $mfile;
	147	open M, $mfile or return $matches;
	148	while (<M>){
	149	chomp;
	150	next if /^\s*$/;
	151	push @skip, $_;
	152	}
	153	close M;
8e07c86e	154	my $opts = $Is_VMS ? 'oi ' : 'o ';
005c1a0e	155	my $sub = "\$matches = "
005c1a0e	156	. "sub { my(\$arg)=\@_; return 1 if "
8e07c86e	157	. join (" \|\| ", (map {s!/!\\/!g; "\$arg =~ m/$_/$opts"} @skip), 0)
005c1a0e	158	. " }";
	159	eval $sub;
	160	print "Debug: $sub\n" if $Debug;
	161	$matches;
	162	}
	163
	164	sub manicopy {
8e07c86e	165	my($read,$target,$how)=@_;
005c1a0e	166	croak "manicopy() called without target argument" unless defined $target;
8e07c86e	167	$how = 'cp' unless defined $how && $how;
005c1a0e	168	require File::Path;
	169	require File::Basename;
	170	my(%dirs,$file);
8e07c86e	171	$target = VMS::Filespec::unixify($target) if $Is_VMS;
84876ac5	172	umask 0 unless $Is_VMS;
84876ac5	173	File::Path::mkpath([ $target ],1,$Is_VMS ? undef : 0755);
005c1a0e	174	foreach $file (keys %$read){
8e07c86e	175	$file = VMS::Filespec::unixify($file) if $Is_VMS;
84876ac5	176	if ($file =~ m!/!) { # Ilya, that hurts, I fear, or maybe not?
	177	my $dir = File::Basename::dirname($file);
	178	$dir = VMS::Filespec::unixify($dir) if $Is_VMS;
	179	File::Path::mkpath(["$target/$dir"],1,$Is_VMS ? undef : 0755);
	180	}
8e07c86e	181	if ($Is_VMS) { vms_cp_if_diff($file,"$target/$file"); }
8e07c86e	182	else { cp_if_diff($file, "$target/$file", $how); }
005c1a0e	183	}
	184	}
	185
	186	sub cp_if_diff {
8a1da95f	187	my($from, $to, $how)=@_;
005c1a0e	188	-f $from \|\| carp "$0: $from not found";
8e07c86e	189	my($diff) = 0;
	190	local(F,T);
	191	open(F,$from) or croak "Can't read $from: $!\n";
	192	if (open(T,$to)) {
	193	while (<F>) { $diff++,last if $_ ne <T>; }
	194	$diff++ unless eof(T);
	195	close T;
	196	}
	197	else { $diff++; }
	198	close F;
	199	if ($diff) {
	200	if (-e $to) {
	201	unlink($to) or confess "unlink $to: $!";
	202	}
8a1da95f	203	STRICT_SWITCH: {
	204	best($from,$to), last STRICT_SWITCH if $how eq 'best';
	205	cp($from,$to), last STRICT_SWITCH if $how eq 'cp';
	206	ln($from,$to), last STRICT_SWITCH if $how eq 'ln';
	207	}
8e07c86e	208	}
	209	}
	210
	211	# Do the comparisons here rather than spawning off another process
	212	sub vms_cp_if_diff {
	213	my($from,$to) = @_;
	214	my($diff) = 0;
	215	local(F,T);
	216	open(F,$from) or croak "Can't read $from: $!\n";
	217	if (open(T,$to)) {
	218	while (<F>) { $diff++,last if $_ ne <T>; }
	219	$diff++ unless eof(T);
	220	close T;
	221	}
	222	else { $diff++; }
	223	close F;
	224	if ($diff) {
84876ac5	225	system('copy',VMS::Filespec::vmsify($from),VMS::Filespec::vmsify($to)) & 1
8e07c86e	226	or confess "Copy failed: $!";
005c1a0e	227	}
	228	}
	229
8e07c86e	230	sub cp {
8e07c86e	231	my ($srcFile, $dstFile) = @_;
79dd614e	232	my ($perm,$access,$mod) = (stat $srcFile)[2,8,9];
79dd614e	233	copy($srcFile,$dstFile);
8e07c86e	234	utime $access, $mod, $dstFile;
	235	# chmod a+rX-w,go-w
	236	chmod( 0444 \| ( $perm & 0111 ? 0111 : 0 ), $dstFile );
	237	}
	238
	239	sub ln {
	240	my ($srcFile, $dstFile) = @_;
	241	link($srcFile, $dstFile);
	242	local($_) = $dstFile; # chmod a+r,go-w+X (except "X" only applies to u=x)
	243	my $mode= 0444 \| (stat)[2] & 0700;
	244	chmod( $mode \| ( $mode & 0100 ? 0111 : 0 ), $_ );
	245	}
	246
4633a7c4	247	sub best {
	248	my ($srcFile, $dstFile) = @_;
	249	if (-l $srcFile) {
	250	cp($srcFile, $dstFile);
	251	} else {
	252	ln($srcFile, $dstFile);
	253	}
	254	}
	255
005c1a0e	256	1;
79dd614e	257
	258	__END__
	259
	260	=head1 NAME
	261
	262	ExtUtils::Manifest - utilities to write and check a MANIFEST file
	263
	264	=head1 SYNOPSIS
	265
	266	C<require ExtUtils::Manifest;>
	267
	268	C<ExtUtils::Manifest::mkmanifest;>
	269
	270	C<ExtUtils::Manifest::manicheck;>
	271
	272	C<ExtUtils::Manifest::filecheck;>
	273
	274	C<ExtUtils::Manifest::fullcheck;>
	275
	276	C<ExtUtils::Manifest::skipcheck;>
	277
	278	C<ExtUtild::Manifest::manifind();>
	279
	280	C<ExtUtils::Manifest::maniread($file);>
	281
	282	C<ExtUtils::Manifest::manicopy($read,$target,$how);>
	283
	284	=head1 DESCRIPTION
	285
	286	Mkmanifest() writes all files in and below the current directory to a
	287	file named in the global variable $ExtUtils::Manifest::MANIFEST (which
	288	defaults to C<MANIFEST>) in the current directory. It works similar to
	289
	290	find . -print
	291
	292	but in doing so checks each line in an existing C<MANIFEST> file and
	293	includes any comments that are found in the existing C<MANIFEST> file
	294	in the new one. Anything between white space and an end of line within
	295	a C<MANIFEST> file is considered to be a comment. Filenames and
	296	comments are seperated by one or more TAB characters in the
	297	output. All files that match any regular expression in a file
	298	C<MANIFEST.SKIP> (if such a file exists) are ignored.
	299
f1387719	300	Manicheck() checks if all the files within a C<MANIFEST> in the
	301	current directory really do exist. It only reports discrepancies and
	302	exits silently if MANIFEST and the tree below the current directory
	303	are in sync.
79dd614e	304
	305	Filecheck() finds files below the current directory that are not
	306	mentioned in the C<MANIFEST> file. An optional file C<MANIFEST.SKIP>
	307	will be consulted. Any file matching a regular expression in such a
	308	file will not be reported as missing in the C<MANIFEST> file.
	309
	310	Fullcheck() does both a manicheck() and a filecheck().
	311
	312	Skipcheck() lists all the files that are skipped due to your
	313	C<MANIFEST.SKIP> file.
	314
	315	Manifind() retruns a hash reference. The keys of the hash are the
	316	files found below the current directory.
	317
	318	Maniread($file) reads a named C<MANIFEST> file (defaults to
	319	C<MANIFEST> in the current directory) and returns a HASH reference
	320	with files being the keys and comments being the values of the HASH.
	321
	322	I<Manicopy($read,$target,$how)> copies the files that are the keys in
	323	the HASH I<%$read> to the named target directory. The HASH reference
	324	I<$read> is typically returned by the maniread() function. This
	325	function is useful for producing a directory tree identical to the
	326	intended distribution tree. The third parameter $how can be used to
	327	specify a different methods of "copying". Valid values are C<cp>,
	328	which actually copies the files, C<ln> which creates hard links, and
	329	C<best> which mostly links the files but copies any symbolic link to
	330	make a tree without any symbolic link. Best is the default.
	331
	332	=head1 MANIFEST.SKIP
	333
	334	The file MANIFEST.SKIP may contain regular expressions of files that
	335	should be ignored by mkmanifest() and filecheck(). The regular
	336	expressions should appear one on each line. A typical example:
	337
	338	\bRCS\b
	339	^MANIFEST\.
	340	^Makefile$
	341	~$
	342	\.html$
	343	\.old$
	344	^blib/
	345	^MakeMaker-\d
	346
	347	=head1 EXPORT_OK
	348
	349	C<&mkmanifest>, C<&manicheck>, C<&filecheck>, C<&fullcheck>,
	350	C<&maniread>, and C<&manicopy> are exportable.
	351
	352	=head1 GLOBAL VARIABLES
	353
	354	C<$ExtUtils::Manifest::MANIFEST> defaults to C<MANIFEST>. Changing it
	355	results in both a different C<MANIFEST> and a different
	356	C<MANIFEST.SKIP> file. This is useful if you want to maintain
	357	different distributions for different audiences (say a user version
	358	and a developer version including RCS).
	359
81ff29e3	360	C<$ExtUtils::Manifest::Quiet> defaults to 0. If set to a true value,
79dd614e	361	all functions act silently.
	362
	363	=head1 DIAGNOSTICS
	364
	365	All diagnostic output is sent to C<STDERR>.
	366
	367	=over
	368
	369	=item C<Not in MANIFEST:> I<file>
	370
	371	is reported if a file is found, that is missing in the C<MANIFEST>
	372	file which is excluded by a regular expression in the file
	373	C<MANIFEST.SKIP>.
	374
	375	=item C<No such file:> I<file>
	376
	377	is reported if a file mentioned in a C<MANIFEST> file does not
	378	exist.
	379
	380	=item C<MANIFEST:> I<$!>
	381
	382	is reported if C<MANIFEST> could not be opened.
	383
	384	=item C<Added to MANIFEST:> I<file>
	385
	386	is reported by mkmanifest() if $Verbose is set and a file is added
	387	to MANIFEST. $Verbose is set to 1 by default.
	388
	389	=back
	390
	391	=head1 SEE ALSO
	392
	393	L<ExtUtils::MakeMaker> which has handy targets for most of the functionality.
	394
	395	=head1 AUTHOR
	396
81ff29e3	397	Andreas Koenig E<lt>F<koenig@franz.ww.TU-Berlin.DE>E<gt>
79dd614e	398
79dd614e	399	=cut