File Coverage

blib/lib/IO/Uncompress/UnLzma.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

package IO::Uncompress::UnLzma ;

use strict ;
use warnings;
use bytes;

use IO::Compress::Base::Common 2.073 qw(:Status createSelfTiedObject);

use IO::Uncompress::Base 2.073 ;
use IO::Uncompress::Adapter::UnLzma 2.073 ;

require Exporter ;
our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $UnLzmaError);

$VERSION = '2.073';
$UnLzmaError = '';

@ISA    = qw( IO::Uncompress::Base Exporter );
@EXPORT_OK = qw( $UnLzmaError unlzma ) ;
#%EXPORT_TAGS = %IO::Uncompress::Base::EXPORT_TAGS ;
push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
#Exporter::export_ok_tags('all');


sub new
{
    my $class = shift ;
    my $obj = createSelfTiedObject($class, \$UnLzmaError);

    $obj->_create(undef, 0, @_);
}

sub unlzma
{
    my $obj = createSelfTiedObject(undef, \$UnLzmaError);
    return $obj->_inf(@_);
}

#our %PARAMS = (
        #'verbosity' => [IO::Compress::Base::Common::Parse_boolean,   0],
        #'small'     => [IO::Compress::Base::Common::Parse_boolean,   0],
#    );

sub getExtraParams
{
    return ();
}


sub ckParams
{
    my $self = shift ;
    my $got = shift ;

    return 1;
}

sub mkUncomp
{
    my $self = shift ;
    my $got = shift ;

    #my $Small     = $got->getValue('small');
    #my $Verbosity = $got->getValue('verbosity');

    my ($obj, $errstr, $errno) = IO::Uncompress::Adapter::UnLzma::mkUncompObject(
                                                    );

    return $self->saveErrorString(undef, $errstr, $errno)
        if ! defined $obj;

    *$self->{Uncomp} = $obj;

    *$self->{Info} = $self->ckMagic()
        or return 0 ;

    return 1;
}


sub ckMagic
{
    my $self = shift;

    my $got = $self->isLzma(@_);

    if ($got) {
        *$self->{Pending} = *$self->{HeaderPending} ;
    }
    else {
        $self->pushBack(*$self->{HeaderPending});
        *$self->{Uncomp}->reset();
    }
    *$self->{HeaderPending} = '';

    return $got ;
}


sub isLzma
{
    my $self = shift ;
    my $magic = shift;

    $magic = '' unless defined $magic ;

    my $buffer = '';

    $self->smartRead(\$buffer, *$self->{BlockSize}) >= 0
        or return $self->saveErrorString(undef, "No data to read");

    my $temp_buf = $magic . $buffer ;
    *$self->{HeaderPending} = $temp_buf ;
    $buffer = '';
    my $status = *$self->{Uncomp}->uncompr(\$temp_buf, \$buffer, $self->smartEof()) ;

    return $self->saveErrorString(undef, *$self->{Uncomp}{Error}, STATUS_ERROR)
        if $status == STATUS_ERROR;

    $self->pushBack($temp_buf)  ;

    return $self->saveErrorString(undef, "unexpected end of file", STATUS_ERROR)
        if $self->smartEof() && $status != STATUS_ENDSTREAM;

    #my $buf_len = *$self->{Uncomp}->uncompressedBytes();
    my $buf_len = length $buffer;

    if ($status == STATUS_ENDSTREAM) {
        if (*$self->{MultiStream}
                    && (length $temp_buf || ! $self->smartEof())){
            *$self->{NewStream} = 1 ;
            *$self->{EndStream} = 0 ;
        }
        else {
            *$self->{EndStream} = 1 ;
        }
    }
    *$self->{HeaderPending} = $buffer ;
    *$self->{InflatedBytesRead} = $buf_len ;
    *$self->{TotalInflatedBytesRead} += $buf_len ;
    *$self->{Type} = 'lzma';

    $self->saveStatus(STATUS_OK);

    return {
        'Type'          => 'lzma',
        'HeaderLength'  => 0,
        'TrailerLength' => 0,
        'Header'        => ''
        };


    return '';

#    my $magic ;
#    $self->smartReadExact(\$magic, 4);
#
#    *$self->{HeaderPending} = $magic ;
#
#    return $self->HeaderError("Header size is " .
#                                        4 . " bytes")
#        if length $magic != 4;
#
#    return $self->HeaderError("Bad Magic.")
#        if ! isBzip2Magic($magic) ;
#
#
#    *$self->{Type} = 'bzip2';
#    return $magic;
}


sub readHeader
{
    my $self = shift;
    my $magic = shift ;

    $self->pushBack($magic);
    *$self->{HeaderPending} = '';


    return {
        'Type'              => 'lzma',
        'FingerprintLength' => 0,
        'HeaderLength'      => 0,
        'TrailerLength'     => 0,
        'Header'            => ''
        };

}

sub chkTrailer
{
    return STATUS_OK;
}


1 ;

__END__