summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm')
-rwxr-xr-xMaster/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm355
1 files changed, 355 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm b/Master/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm
new file mode 100755
index 00000000000..48f82073355
--- /dev/null
+++ b/Master/tlpkg/tlperl/lib/Compress/Raw/Bzip2.pm
@@ -0,0 +1,355 @@
+
+package Compress::Raw::Bzip2;
+
+use strict ;
+use warnings ;
+
+require 5.004 ;
+require Exporter;
+use AutoLoader;
+use Carp ;
+
+use bytes ;
+our ($VERSION, $XS_VERSION, @ISA, @EXPORT, $AUTOLOAD);
+
+$VERSION = '2.024';
+$XS_VERSION = $VERSION;
+$VERSION = eval $VERSION;
+
+@ISA = qw(Exporter);
+# Items to export into callers namespace by default. Note: do not export
+# names by default without a very good reason. Use EXPORT_OK instead.
+# Do not simply export all your public functions/methods/constants.
+@EXPORT = qw(
+ BZ_RUN
+ BZ_FLUSH
+ BZ_FINISH
+
+ BZ_OK
+ BZ_RUN_OK
+ BZ_FLUSH_OK
+ BZ_FINISH_OK
+ BZ_STREAM_END
+ BZ_SEQUENCE_ERROR
+ BZ_PARAM_ERROR
+ BZ_MEM_ERROR
+ BZ_DATA_ERROR
+ BZ_DATA_ERROR_MAGIC
+ BZ_IO_ERROR
+ BZ_UNEXPECTED_EOF
+ BZ_OUTBUFF_FULL
+ BZ_CONFIG_ERROR
+
+ );
+
+sub AUTOLOAD {
+ my($constname);
+ ($constname = $AUTOLOAD) =~ s/.*:://;
+ my ($error, $val) = constant($constname);
+ Carp::croak $error if $error;
+ no strict 'refs';
+ *{$AUTOLOAD} = sub { $val };
+ goto &{$AUTOLOAD};
+
+}
+
+use constant FLAG_APPEND => 1 ;
+use constant FLAG_CRC => 2 ;
+use constant FLAG_ADLER => 4 ;
+use constant FLAG_CONSUME_INPUT => 8 ;
+
+eval {
+ require XSLoader;
+ XSLoader::load('Compress::Raw::Bzip2', $XS_VERSION);
+ 1;
+}
+or do {
+ require DynaLoader;
+ local @ISA = qw(DynaLoader);
+ bootstrap Compress::Raw::Bzip2 $XS_VERSION ;
+};
+
+#sub Compress::Raw::Bzip2::new
+#{
+# my $class = shift ;
+# my ($ptr, $status) = _new(@_);
+# return wantarray ? (undef, $status) : undef
+# unless $ptr ;
+# my $obj = bless [$ptr], $class ;
+# return wantarray ? ($obj, $status) : $obj;
+#}
+#
+#package Compress::Raw::Bunzip2 ;
+#
+#sub Compress::Raw::Bunzip2::new
+#{
+# my $class = shift ;
+# my ($ptr, $status) = _new(@_);
+# return wantarray ? (undef, $status) : undef
+# unless $ptr ;
+# my $obj = bless [$ptr], $class ;
+# return wantarray ? ($obj, $status) : $obj;
+#}
+
+package Compress::Raw::Bzip2;
+
+1;
+
+__END__
+
+
+=head1 NAME
+
+Compress::Raw::Bzip2 - Low-Level Interface to bzip2 compression library
+
+=head1 SYNOPSIS
+
+ use Compress::Raw::Bzip2 ;
+
+ my ($bz, $status) = new Compress::Raw::Bzip2 [OPTS]
+ or die "Cannot create bzip2 object: $bzerno\n";
+
+ $status = $bz->bzdeflate($input, $output);
+ $status = $bz->bzflush($output);
+ $status = $bz->bzclose($output);
+
+ my ($bz, $status) = new Compress::Raw::Bunzip2 [OPTS]
+ or die "Cannot create bunzip2 object: $bzerno\n";
+
+ $status = $bz->bzinflate($input, $output);
+
+ my $version = Compress::Raw::Bzip2::bzlibversion();
+
+=head1 DESCRIPTION
+
+C<Compress::Raw::Bzip2> provides an interface to the in-memory
+compression/uncompression functions from the bzip2 compression library.
+
+Although the primary purpose for the existence of C<Compress::Raw::Bzip2>
+is for use by the C<IO::Compress::Bzip2> and C<IO::Compress::Bunzip2>
+modules, it can be used on its own for simple compression/uncompression
+tasks.
+
+=head1 Compression
+
+=head2 ($z, $status) = new Compress::Raw::Bzip2 $appendOutput, $blockSize100k, $workfactor;
+
+Creates a new compression object.
+
+If successful, it will return the initialised compression object, C<$z>
+and a C<$status> of C<BZ_OK> in a list context. In scalar context it
+returns the deflation object, C<$z>, only.
+
+If not successful, the returned compression object, C<$z>, will be
+I<undef> and C<$status> will hold the a I<bzip2> error code.
+
+Below is a list of the valid options:
+
+=over 5
+
+=item B<$appendOutput>
+
+Controls whether the compressed data is appended to the output buffer in
+the C<bzdeflate>, C<bzflush> and C<bzclose> methods.
+
+Defaults to 1.
+
+=item B<$blockSize100k>
+
+To quote the bzip2 documentation
+
+ blockSize100k specifies the block size to be used for compression. It
+ should be a value between 1 and 9 inclusive, and the actual block size
+ used is 100000 x this figure. 9 gives the best compression but takes
+ most memory.
+
+Defaults to 1.
+
+=item B<$workfactor>
+
+To quote the bzip2 documentation
+
+ This parameter controls how the compression phase behaves when
+ presented with worst case, highly repetitive, input data. If
+ compression runs into difficulties caused by repetitive data, the
+ library switches from the standard sorting algorithm to a fallback
+ algorithm. The fallback is slower than the standard algorithm by
+ perhaps a factor of three, but always behaves reasonably, no matter how
+ bad the input.
+
+ Lower values of workFactor reduce the amount of effort the standard
+ algorithm will expend before resorting to the fallback. You should set
+ this parameter carefully; too low, and many inputs will be handled by
+ the fallback algorithm and so compress rather slowly, too high, and
+ your average-to-worst case compression times can become very large. The
+ default value of 30 gives reasonable behaviour over a wide range of
+ circumstances.
+
+ Allowable values range from 0 to 250 inclusive. 0 is a special case,
+ equivalent to using the default value of 30.
+
+Defaults to 0.
+
+=back
+
+=head2 $status = $bz->bzdeflate($input, $output);
+
+Reads the contents of C<$input>, compresses it and writes the compressed
+data to C<$output>.
+
+Returns C<BZ_RUN_OK> on success and a C<bzip2> error code on failure.
+
+If C<appendOutput> is enabled in the constructor for the bzip2 object, the
+compressed data will be appended to C<$output>. If not enabled, C<$output>
+will be truncated before the compressed data is written to it.
+
+=head2 $status = $bz->bzflush($output);
+
+Flushes any pending compressed data to C<$output>.
+
+Returns C<BZ_RUN_OK> on success and a C<bzip2> error code on failure.
+
+=head2 $status = $bz->bzclose($output);
+
+Terminates the compressed data stream and flushes any pending compressed
+data to C<$output>.
+
+Returns C<BZ_STREAM_END> on success and a C<bzip2> error code on failure.
+
+=head2 Example
+
+=head1 Uncompression
+
+=head2 ($z, $status) = new Compress::Raw::Bunzip2 $appendOutput, $consumeInput, $small, $limitOutput;
+
+If successful, it will return the initialised uncompression object, C<$z>
+and a C<$status> of C<BZ_OK> in a list context. In scalar context it
+returns the deflation object, C<$z>, only.
+
+If not successful, the returned uncompression object, C<$z>, will be
+I<undef> and C<$status> will hold the a I<bzip2> error code.
+
+Below is a list of the valid options:
+
+=over 5
+
+=item B<$appendOutput>
+
+Controls whether the compressed data is appended to the output buffer in the
+C<bzinflate>, C<bzflush> and C<bzclose> methods.
+
+Defaults to 1.
+
+=item B<$consumeInput>
+
+=item B<$small>
+
+To quote the bzip2 documentation
+
+ If small is nonzero, the library will use an alternative decompression
+ algorithm which uses less memory but at the cost of decompressing more
+ slowly (roughly speaking, half the speed, but the maximum memory
+ requirement drops to around 2300k).
+
+Defaults to 0.
+
+=item B<$limitOutput>
+
+The C<LimitOutput> option changes the behavior of the C<< $i->bzinflate >>
+method so that the amount of memory used by the output buffer can be
+limited.
+
+When C<LimitOutput> is used the size of the output buffer used will either
+be the 16k or the amount of memory already allocated to C<$output>,
+whichever is larger. Predicting the output size available is tricky, so
+don't rely on getting an exact output buffer size.
+
+When C<LimitOutout> is not specified C<< $i->bzinflate >> will use as much
+memory as it takes to write all the uncompressed data it creates by
+uncompressing the input buffer.
+
+If C<LimitOutput> is enabled, the C<ConsumeInput> option will also be
+enabled.
+
+This option defaults to false.
+
+=back
+
+=head2 $status = $z->bzinflate($input, $output);
+
+Uncompresses C<$input> and writes the uncompressed data to C<$output>.
+
+Returns C<BZ_OK> if the uncompression was successful, but the end of the
+compressed data stream has not been reached. Returns C<BZ_STREAM_END> on
+successful uncompression and the end of the compression stream has been
+reached.
+
+If C<consumeInput> is enabled in the constructor for the bunzip2 object,
+C<$input> will have all compressed data removed from it after
+uncompression. On C<BZ_OK> return this will mean that C<$input> will be an
+empty string; when C<BZ_STREAM_END> C<$input> will either be an empty
+string or will contain whatever data immediately followed the compressed
+data stream.
+
+If C<appendOutput> is enabled in the constructor for the bunzip2 object,
+the uncompressed data will be appended to C<$output>. If not enabled,
+C<$output> will be truncated before the uncompressed data is written to it.
+
+=head1 Misc
+
+=head2 my $version = Compress::Raw::Bzip2::bzlibversion();
+
+Returns the version of the underlying bzip2 library.
+
+=head1 Constants
+
+The following bzip2 constants are exported by this module
+
+ BZ_RUN
+ BZ_FLUSH
+ BZ_FINISH
+
+ BZ_OK
+ BZ_RUN_OK
+ BZ_FLUSH_OK
+ BZ_FINISH_OK
+ BZ_STREAM_END
+ BZ_SEQUENCE_ERROR
+ BZ_PARAM_ERROR
+ BZ_MEM_ERROR
+ BZ_DATA_ERROR
+ BZ_DATA_ERROR_MAGIC
+ BZ_IO_ERROR
+ BZ_UNEXPECTED_EOF
+ BZ_OUTBUFF_FULL
+ BZ_CONFIG_ERROR
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+The primary site for the bzip2 program is F<http://www.bzip.org>.
+
+See the module L<Compress::Bzip2|Compress::Bzip2>
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, F<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2010 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+