MAJOR=13
MINOR=0
DEVNAME=input/js0
  0   ˆl–Ü4ý( )„±¨ *W+uLZ7ÿÂ„byŸ_‹uÐb&=LV[(ÂÁ ?÷     package IO::Uncompress::UnXz ;

use strict ;
use warnings;
use bytes;

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

use IO::Uncompress::Base 2.101 ;
use IO::Uncompress::Adapter::UnXz 2.101 ;

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

$VERSION = '2.101';
$UnXzError = '';

@ISA    = qw( IO::Uncompress::Base Exporter );
@EXPORT_OK = qw( $UnXzError unxz ) ;
#%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, \$UnXzError);

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

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

our %PARAMS = (
        'memlimit' => [IO::Compress::Base::Common::Parse_unsigned, 128 * 1024 * 1024],
        'flags'    => [IO::Compress::Base::Common::Parse_boolean,  0],
    );

sub getExtraParams
{
    return %PARAMS ;
}


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

    return 1;
}

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

     my $magic = $self->ckMagic()
        or return 0;

    *$self->{Info} = $self->readHeader($magic)
        or return undef ;

    my $memlimit = $got->getValue('memlimit');
    my $flags    = $got->getValue('flags');

    my ($obj, $errstr, $errno) =  IO::Uncompress::Adapter::UnXz::mkUncompObject(
                                                    $memlimit, $flags);

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

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

    return 1;

}


use constant XZ_ID_SIZE => 6;
use constant XZ_MAGIC   => "\0xFD". '7zXZ'. "\0x00" ;

sub ckMagic
{
    my $self = shift;

    my $magic ;
    $self->smartReadExact(\$magic, XZ_ID_SIZE);

    *$self->{HeaderPending} = $magic ;

    return $self->HeaderError("Header size is " .
                                        XZ_ID_SIZE . " bytes")
        if length $magic != XZ_ID_SIZE;

    return $self->HeaderError("Bad Magic.")
        if ! isXzMagic($magic) ;


    *$self->{Type} = 'xz';
    return $magic;
}

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

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


    return {
        'Type'              => 'xz',
        'FingerprintLength' => XZ_ID_SIZE,
        'HeaderLength'      => XZ_ID_SIZE,
        'TrailerLength'     => 0,
        'Header'            => '$magic'
        };

}

sub chkTrailer
{
    return STATUS_OK;
}


sub isXzMagic
{
    my $buffer = shift ;
    return $buffer =~ /^\xFD\x37\x7A\x58\x5A\x00/;
}

1 ;

__END__


=head1 NAME

IO::Uncompress::UnXz - Read xz files/buffers

=head1 SYNOPSIS

    use IO::Uncompress::UnXz qw(unxz $UnXzError) ;

    my $status = unxz $input => $output [,OPTS]
        or die "unxz failed: $UnXzError\n";

    my $z = IO::Uncompress::UnXz->new( $input [OPTS] )
        or die "unxz failed: $UnXzError\n";

    $status = $z->read($buffer)
    $status = $z->read($buffer, $length)
    $status = $z->read($buffer, $length, $offset)
    $line = $z->getline()
    $char = $z->getc()
    $char = $z->ungetc()
    $char = $z->opened()

    $data = $z->trailingData()
    $status = $z->nextStream()
    $data = $z->getHeaderInfo()
    $z->tell()
    $z->seek($position, $whence)
    $z->binmode()
    $z->fileno()
    $z->eof()
    $z->close()

    $UnXzError ;

    # IO::File mode

    <$z>
    read($z, $buffer);
    read($z, $buffer, $length);
    read($z, $buffer, $length, $offset);
    tell($z)
    seek($z, $position, $whence)
    binmode($z)
    fileno($z)
    eof($z)
    close($z)

=head1 DESCRIPTION

This module provides a Perl interface that allows the reading of
lzma files/buffers.

For writing xz files/buffers, see the companion module IO::Compress::Xz.

=head1 Functional Interface

A top-level function, C<unxz>, is provided to carry out
"one-shot" uncompression between buffers and/or files. For