The Perl Toolchain Summit 2025 Needs You: You can help 🙏 Learn more

BINGOS / Devel-PatchPerl-2.10-TRIAL / perl.git / cpan / IO-Compress / lib / IO / Uncompress / Adapter / Inflate.pm 

            

              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

              
package IO::Uncompress::Adapter::Inflate;
use strict;
use warnings;
use bytes;
use IO::Compress::Base::Common  2.213 qw(:Status);
use Compress::Raw::Zlib  2.213 qw(Z_OK Z_BUF_ERROR Z_STREAM_END Z_FINISH MAX_WBITS);
our ($VERSION);
$VERSION = '2.213';
sub mkUncompObject
{
    my $crc32   = shift || 1;
    my $adler32 = shift || 1;
    my $scan    = shift || 0;
    my $inflate ;
    my $status ;
    if ($scan)
    {
        ($inflate, $status) = Compress::Raw::Zlib::InflateScan->new(
                                    #LimitOutput  => 1,
                                    CRC32        => $crc32,
                                    ADLER32      => $adler32,
                                    WindowBits   => - MAX_WBITS );
    }
    else
    {
        ($inflate, $status) = Compress::Raw::Zlib::Inflate->new(
                                    AppendOutput => 1,
                                    LimitOutput  => 1,
                                    CRC32        => $crc32,
                                    ADLER32      => $adler32,
                                    WindowBits   => - MAX_WBITS );
    }
    return (undef, "Could not create Inflation object: $status", $status)
        if $status != Z_OK ;
    return bless {'Inf'        => $inflate,
                  'CompSize'   => 0,
                  'UnCompSize' => 0,
                  'Error'      => '',
                  'ConsumesInput' => 1,
                 } ;
}
sub uncompr
{
    my $self = shift ;
    my $from = shift ;
    my $to   = shift ;
    my $eof  = shift ;
    my $inf   = $self->{Inf};
    my $status = $inf->inflate($from, $to, $eof);
    $self->{ErrorNo} = $status;
    if ($status != Z_OK && $status != Z_STREAM_END && $status != Z_BUF_ERROR)
    {
        $self->{Error} = "Inflation Error: $status";
        return STATUS_ERROR;
    }
    return STATUS_OK        if $status == Z_BUF_ERROR ; # ???
    return STATUS_OK        if $status == Z_OK ;
    return STATUS_ENDSTREAM if $status == Z_STREAM_END ;
    return STATUS_ERROR ;
}
sub reset
{
    my $self = shift ;
    $self->{Inf}->inflateReset();
    return STATUS_OK ;
}
#sub count
#{
#    my $self = shift ;
#    $self->{Inf}->inflateCount();
#}
sub crc32
{
    my $self = shift ;
    $self->{Inf}->crc32();
}
sub compressedBytes
{
    my $self = shift ;
    $self->{Inf}->compressedBytes();
}
sub uncompressedBytes
{
    my $self = shift ;
    $self->{Inf}->uncompressedBytes();
}
sub adler32
{
    my $self = shift ;
    $self->{Inf}->adler32();
}
sub sync
{
    my $self = shift ;
    ( $self->{Inf}->inflateSync(@_) == Z_OK)
            ? STATUS_OK
            : STATUS_ERROR ;
}
sub getLastBlockOffset
{
    my $self = shift ;
    $self->{Inf}->getLastBlockOffset();
}
sub getEndOffset
{
    my $self = shift ;
    $self->{Inf}->getEndOffset();
}
sub resetLastBlockByte
{
    my $self = shift ;
    $self->{Inf}->resetLastBlockByte(@_);
}
sub createDeflateStream
{
    my $self = shift ;
    my $deflate = $self->{Inf}->createDeflateStream(@_);
    return bless {'Def'        => $deflate,
                  'CompSize'   => 0,
                  'UnCompSize' => 0,
                  'Error'      => '',
                 }, 'IO::Compress::Adapter::Deflate';
}
1;
__END__