← Index
NYTProf Performance Profile   « line view »
For /usr/sbin/pkg_info
  Run on Mon Aug 7 09:39:31 2017
Reported on Mon Aug 7 09:40:21 2017

Filename/usr/libdata/perl5/amd64-openbsd/IO/Uncompress/Base.pm
StatementsExecuted 127542 statements in 1.43s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
8022980ms980msIO::Uncompress::Base::::closeIO::Uncompress::Base::close
456641145ms10.4sIO::Uncompress::Base::::smartReadIO::Uncompress::Base::smartRead
41603196.6ms10.5sIO::Uncompress::Base::::smartReadExactIO::Uncompress::Base::smartReadExact
401166.6ms11.0sIO::Uncompress::Base::::_createIO::Uncompress::Base::_create
2222145.0ms131msIO::Uncompress::Base::::_raw_readIO::Uncompress::Base::_raw_read
46673127.6ms27.6msIO::Uncompress::Base::::saveStatusIO::Uncompress::Base::saveStatus
401120.5ms144msIO::Uncompress::Base::::checkParamsIO::Uncompress::Base::checkParams
3215219.3ms150msIO::Uncompress::Base::::readIO::Uncompress::Base::read
223216.34ms23.0msIO::Uncompress::Base::::smartEofIO::Uncompress::Base::smartEof
360215.14ms5.14msIO::Uncompress::Base::::pushBackIO::Uncompress::Base::pushBack
40113.86ms3.86msIO::Uncompress::Base::::ungetcIO::Uncompress::Base::ungetc
40113.16ms3.16msIO::Uncompress::Base::::TIEHANDLEIO::Uncompress::Base::TIEHANDLE
182112.04ms23.1msIO::Uncompress::Base::::readBlockIO::Uncompress::Base::readBlock
40111.84ms8.04msIO::Uncompress::Base::::gotoNextStreamIO::Uncompress::Base::gotoNextStream
40211.78ms1.97msIO::Uncompress::Base::::DESTROYIO::Uncompress::Base::DESTROY
40111.39ms2.45msIO::Uncompress::Base::::ckInputParamIO::Uncompress::Base::ckInputParam
18311966µs966µsIO::Uncompress::Base::::setErrInfoIO::Uncompress::Base::setErrInfo
111890µs7.14msIO::Uncompress::Base::::BEGIN@19IO::Uncompress::Base::BEGIN@19
18311839µs839µsIO::Uncompress::Base::::getErrInfoIO::Uncompress::Base::getErrInfo
18211694µs694µsIO::Uncompress::Base::::filterUncompressedIO::Uncompress::Base::filterUncompressed
18211373µs373µsIO::Uncompress::Base::::postBlockChkIO::Uncompress::Base::postBlockChk
4011352µs888µsIO::Uncompress::Base::::resetIO::Uncompress::Base::reset
4011219µs219µsIO::Uncompress::Base::::postCheckParamsIO::Uncompress::Base::postCheckParams
4011197µs197µsIO::Uncompress::Base::::getHeaderInfoIO::Uncompress::Base::getHeaderInfo
4011175µs175µsIO::Uncompress::Base::::UNTIEIO::Uncompress::Base::UNTIE
11150µs74µsIO::Uncompress::Base::::BEGIN@90IO::Uncompress::Base::BEGIN@90
66120µs20µsIO::Uncompress::Base::::_notAvailableIO::Uncompress::Base::_notAvailable
11118µs22µsIO::Uncompress::Base::::BEGIN@4IO::Uncompress::Base::BEGIN@4
11117µs208µsIO::Uncompress::Base::::BEGIN@17IO::Uncompress::Base::BEGIN@17
11113µs30µsIO::Uncompress::Base::::BEGIN@428IO::Uncompress::Base::BEGIN@428
11111µs58µsIO::Uncompress::Base::::BEGIN@20IO::Uncompress::Base::BEGIN@20
11111µs18µsIO::Uncompress::Base::::BEGIN@5IO::Uncompress::Base::BEGIN@5
11110µs69µsIO::Uncompress::Base::::BEGIN@14IO::Uncompress::Base::BEGIN@14
1119µs64µsIO::Uncompress::Base::::BEGIN@15IO::Uncompress::Base::BEGIN@15
1119µs46µsIO::Uncompress::Base::::BEGIN@23IO::Uncompress::Base::BEGIN@23
1115µs5µsIO::Uncompress::Base::::BEGIN@21IO::Uncompress::Base::BEGIN@21
1114µs4µsIO::Uncompress::Base::::BEGIN@22IO::Uncompress::Base::BEGIN@22
0000s0sIO::Uncompress::Base::::HeaderErrorIO::Uncompress::Base::HeaderError
0000s0sIO::Uncompress::Base::::READLINEIO::Uncompress::Base::READLINE
0000s0sIO::Uncompress::Base::::TrailerErrorIO::Uncompress::Base::TrailerError
0000s0sIO::Uncompress::Base::::TruncatedHeaderIO::Uncompress::Base::TruncatedHeader
0000s0sIO::Uncompress::Base::::TruncatedTrailerIO::Uncompress::Base::TruncatedTrailer
0000s0sIO::Uncompress::Base::::__ANON__[:1497]IO::Uncompress::Base::__ANON__[:1497]
0000s0sIO::Uncompress::Base::::_getlineIO::Uncompress::Base::_getline
0000s0sIO::Uncompress::Base::::_infIO::Uncompress::Base::_inf
0000s0sIO::Uncompress::Base::::_rd2IO::Uncompress::Base::_rd2
0000s0sIO::Uncompress::Base::::_singleTargetIO::Uncompress::Base::_singleTarget
0000s0sIO::Uncompress::Base::::autoflushIO::Uncompress::Base::autoflush
0000s0sIO::Uncompress::Base::::binmodeIO::Uncompress::Base::binmode
0000s0sIO::Uncompress::Base::::clearErrorIO::Uncompress::Base::clearError
0000s0sIO::Uncompress::Base::::closeErrorIO::Uncompress::Base::closeError
0000s0sIO::Uncompress::Base::::croakErrorIO::Uncompress::Base::croakError
0000s0sIO::Uncompress::Base::::eofIO::Uncompress::Base::eof
0000s0sIO::Uncompress::Base::::errorIO::Uncompress::Base::error
0000s0sIO::Uncompress::Base::::errorNoIO::Uncompress::Base::errorNo
0000s0sIO::Uncompress::Base::::filenoIO::Uncompress::Base::fileno
0000s0sIO::Uncompress::Base::::getcIO::Uncompress::Base::getc
0000s0sIO::Uncompress::Base::::getlineIO::Uncompress::Base::getline
0000s0sIO::Uncompress::Base::::getlinesIO::Uncompress::Base::getlines
0000s0sIO::Uncompress::Base::::input_line_numberIO::Uncompress::Base::input_line_number
0000s0sIO::Uncompress::Base::::nextStreamIO::Uncompress::Base::nextStream
0000s0sIO::Uncompress::Base::::openedIO::Uncompress::Base::opened
0000s0sIO::Uncompress::Base::::retErrIO::Uncompress::Base::retErr
0000s0sIO::Uncompress::Base::::saveErrorStringIO::Uncompress::Base::saveErrorString
0000s0sIO::Uncompress::Base::::seekIO::Uncompress::Base::seek
0000s0sIO::Uncompress::Base::::smartSeekIO::Uncompress::Base::smartSeek
0000s0sIO::Uncompress::Base::::smartTellIO::Uncompress::Base::smartTell
0000s0sIO::Uncompress::Base::::smartWriteIO::Uncompress::Base::smartWrite
0000s0sIO::Uncompress::Base::::streamCountIO::Uncompress::Base::streamCount
0000s0sIO::Uncompress::Base::::tellIO::Uncompress::Base::tell
0000s0sIO::Uncompress::Base::::trailingDataIO::Uncompress::Base::trailingData
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1
2package IO::Uncompress::Base ;
3
4230µs227µs
# spent 22µs (18+4) within IO::Uncompress::Base::BEGIN@4 which was called: # once (18µs+4µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 4
use strict ;
# spent 22µs making 1 call to IO::Uncompress::Base::BEGIN@4 # spent 4µs making 1 call to strict::import
5288µs226µs
# spent 18µs (11+8) within IO::Uncompress::Base::BEGIN@5 which was called: # once (11µs+8µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 5
use warnings;
# spent 18µs making 1 call to IO::Uncompress::Base::BEGIN@5 # spent 8µs making 1 call to warnings::import
6#use bytes;
7
8our (@ISA, $VERSION, @EXPORT_OK, %EXPORT_TAGS);
9111µs@ISA = qw(Exporter IO::File);
10
11
1211µs$VERSION = '2.069_001';
13
14233µs2128µs
# spent 69µs (10+59) within IO::Uncompress::Base::BEGIN@14 which was called: # once (10µs+59µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 14
use constant G_EOF => 0 ;
# spent 69µs making 1 call to IO::Uncompress::Base::BEGIN@14 # spent 59µs making 1 call to constant::import
15232µs2120µs
# spent 64µs (9+56) within IO::Uncompress::Base::BEGIN@15 which was called: # once (9µs+56µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 15
use constant G_ERR => -1 ;
# spent 64µs making 1 call to IO::Uncompress::Base::BEGIN@15 # spent 56µs making 1 call to constant::import
16
17351µs3400µs
# spent 208µs (17+191) within IO::Uncompress::Base::BEGIN@17 which was called: # once (17µs+191µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 17
use IO::Compress::Base::Common 2.069 ;
# spent 208µs making 1 call to IO::Uncompress::Base::BEGIN@17 # spent 182µs making 1 call to Exporter::import # spent 9µs making 1 call to UNIVERSAL::VERSION
18
192231µs27.32ms
# spent 7.14ms (890µs+6.25) within IO::Uncompress::Base::BEGIN@19 which was called: # once (890µs+6.25ms) by IO::Uncompress::RawInflate::BEGIN@11 at line 19
use IO::File ;
# spent 7.14ms making 1 call to IO::Uncompress::Base::BEGIN@19 # spent 184µs making 1 call to Exporter::import
20228µs2104µs
# spent 58µs (11+46) within IO::Uncompress::Base::BEGIN@20 which was called: # once (11µs+46µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 20
use Symbol;
# spent 58µs making 1 call to IO::Uncompress::Base::BEGIN@20 # spent 46µs making 1 call to Exporter::import
21222µs15µs
# spent 5µs within IO::Uncompress::Base::BEGIN@21 which was called: # once (5µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 21
use Scalar::Util ();
# spent 5µs making 1 call to IO::Uncompress::Base::BEGIN@21
22221µs14µs
# spent 4µs within IO::Uncompress::Base::BEGIN@22 which was called: # once (4µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 22
use List::Util ();
# spent 4µs making 1 call to IO::Uncompress::Base::BEGIN@22
232269µs284µs
# spent 46µs (9+38) within IO::Uncompress::Base::BEGIN@23 which was called: # once (9µs+38µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 23
use Carp ;
# spent 46µs making 1 call to IO::Uncompress::Base::BEGIN@23 # spent 38µs making 1 call to Exporter::import
24
2512µs%EXPORT_TAGS = ( );
2612µspush @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
27
28sub smartRead
29
# spent 10.4s (145ms+10.3) within IO::Uncompress::Base::smartRead which was called 4566 times, avg 2.29ms/call: # 4160 times (124ms+10.3s) by IO::Uncompress::Base::smartReadExact at line 195, avg 2.50ms/call # 183 times (3.97ms+9.43ms) by IO::Uncompress::Base::smartEof at line 219, avg 73µs/call # 182 times (17.1ms+3.90ms) by IO::Uncompress::Base::readBlock at line 836, avg 116µs/call # 41 times (688µs+0s) by IO::Uncompress::Base::_raw_read at line 949, avg 17µs/call
{
3045663.84ms my $self = $_[0];
3145663.33ms my $out = $_[1];
3245664.49ms my $size = $_[2];
3345664.01ms $$out = "" ;
34
3545663.14ms my $offset = 0 ;
3645663.17ms my $status = 1;
37
38
3945664.01ms if (defined *$self->{InputLength}) {
40 return 0
41 if *$self->{InputLengthRemaining} <= 0 ;
42 $size = List::Util::min($size, *$self->{InputLengthRemaining});
43 }
44
4545664.10ms if ( length *$self->{Prime} ) {
462632.38ms $$out = substr(*$self->{Prime}, 0, $size) ;
47263302µs substr(*$self->{Prime}, 0, $size) = '' ;
48263294µs if (length $$out == $size) {
49 *$self->{InputLengthRemaining} -= length $$out
50121107µs if defined *$self->{InputLength};
51
52121476µs return length $$out ;
53 }
54142110µs $offset = length $$out ;
55 }
56
5744453.39ms my $get_size = $size - $offset ;
58
5944456.86ms if (defined *$self->{FH}) {
6044456.87ms if ($offset) {
61 # Not using this
62 #
63 # *$self->{FH}->read($$out, $get_size, $offset);
64 #
65 # because the filehandle may not support the offset parameter
66 # An example is Net::FTP
67142274µs my $tmp = '';
68142506µs1421.13ms $status = *$self->{FH}->read($tmp, $get_size) ;
# spent 1.13ms making 142 calls to IO::Handle::read, avg 8µs/call
691423.29ms substr($$out, $offset) = $tmp
70 if defined $status && $status > 0 ;
71 }
72 else
73430315.1ms430310.3s { $status = *$self->{FH}->read($$out, $get_size) }
# spent 10.3s making 4303 calls to IO::Handle::read, avg 2.39ms/call
74 }
75 elsif (defined *$self->{InputEvent}) {
76 my $got = 1 ;
77 while (length $$out < $size) {
78 last
79 if ($got = *$self->{InputEvent}->($$out, $get_size)) <= 0;
80 }
81
82 if (length $$out > $size ) {
83 *$self->{Prime} = substr($$out, $size, length($$out));
84 substr($$out, $size, length($$out)) = '';
85 }
86
87 *$self->{EventEof} = 1 if $got <= 0 ;
88 }
89 else {
9021.41ms298µs
# spent 74µs (50+24) within IO::Uncompress::Base::BEGIN@90 which was called: # once (50µs+24µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 90
no warnings 'uninitialized';
# spent 74µs making 1 call to IO::Uncompress::Base::BEGIN@90 # spent 24µs making 1 call to warnings::unimport
91 my $buf = *$self->{Buffer} ;
92 $$buf = '' unless defined $$buf ;
93 substr($$out, $offset) = substr($$buf, *$self->{BufferOffset}, $get_size);
94 if (*$self->{ConsumeInput})
95 { substr($$buf, 0, $get_size) = '' }
96 else
97 { *$self->{BufferOffset} += length($$out) - $offset }
98 }
99
100 *$self->{InputLengthRemaining} -= length($$out) #- $offset
10144453.78ms if defined *$self->{InputLength};
102
10344453.04ms if (! defined $status) {
104 $self->saveStatus($!) ;
105 return STATUS_ERROR;
106 }
107
108444514.2ms444526.4ms $self->saveStatus(length $$out < 0 ? STATUS_ERROR : STATUS_OK) ;
# spent 26.4ms making 4445 calls to IO::Uncompress::Base::saveStatus, avg 6µs/call
109
110444580.8ms return length $$out;
111}
112
113sub pushBack
114
# spent 5.14ms within IO::Uncompress::Base::pushBack which was called 360 times, avg 14µs/call: # 182 times (3.68ms+0s) by IO::Uncompress::Base::_raw_read at line 916, avg 20µs/call # 178 times (1.47ms+0s) by IO::Uncompress::Base::smartEof at line 220, avg 8µs/call
{
115360263µs my $self = shift ;
116
117360387µs return if ! defined $_[0] || length $_[0] == 0 ;
118
1193601.60ms if (defined *$self->{FH} || defined *$self->{InputEvent} ) {
1203603.03ms *$self->{Prime} = $_[0] . *$self->{Prime} ;
121360365µs *$self->{InputLengthRemaining} += length($_[0]);
122 }
123 else {
124 my $len = length $_[0];
125
126 if($len > *$self->{BufferOffset}) {
127 *$self->{Prime} = substr($_[0], 0, $len - *$self->{BufferOffset}) . *$self->{Prime} ;
128 *$self->{InputLengthRemaining} = *$self->{InputLength};
129 *$self->{BufferOffset} = 0
130 }
131 else {
132 *$self->{InputLengthRemaining} += length($_[0]);
133 *$self->{BufferOffset} -= length($_[0]) ;
134 }
135 }
136}
137
138sub smartSeek
139{
140 my $self = shift ;
141 my $offset = shift ;
142 my $truncate = shift;
143 my $position = shift || SEEK_SET;
144
145 # TODO -- need to take prime into account
146 if (defined *$self->{FH})
147 { *$self->{FH}->seek($offset, $position) }
148 else {
149 if ($position == SEEK_END) {
150 *$self->{BufferOffset} = length ${ *$self->{Buffer} } + $offset ;
151 }
152 elsif ($position == SEEK_CUR) {
153 *$self->{BufferOffset} += $offset ;
154 }
155 else {
156 *$self->{BufferOffset} = $offset ;
157 }
158
159 substr(${ *$self->{Buffer} }, *$self->{BufferOffset}) = ''
160 if $truncate;
161 return 1;
162 }
163}
164
165sub smartTell
166{
167 my $self = shift ;
168
169 if (defined *$self->{FH})
170 { return *$self->{FH}->tell() }
171 else
172 { return *$self->{BufferOffset} }
173}
174
175sub smartWrite
176{
177 my $self = shift ;
178 my $out_data = shift ;
179
180 if (defined *$self->{FH}) {
181 # flush needed for 5.8.0
182 defined *$self->{FH}->write($out_data, length $out_data) &&
183 defined *$self->{FH}->flush() ;
184 }
185 else {
186 my $buf = *$self->{Buffer} ;
187 substr($$buf, *$self->{BufferOffset}, length $out_data) = $out_data ;
188 *$self->{BufferOffset} += length($out_data) ;
189 return 1;
190 }
191}
192
193sub smartReadExact
194
# spent 10.5s (96.6ms+10.4) within IO::Uncompress::Base::smartReadExact which was called 4160 times, avg 2.52ms/call: # 4000 times (94.4ms+260ms) by IO::Uncompress::Gunzip::_readGzipHeader at line 208 of IO/Uncompress/Gunzip.pm, avg 89µs/call # 80 times (1.60ms+10.1s) by IO::Uncompress::Gunzip::ckMagic at line 69 of IO/Uncompress/Gunzip.pm, avg 127ms/call # 80 times (607µs+2.89ms) by IO::Uncompress::Gunzip::_readGzipHeader at line 152 of IO/Uncompress/Gunzip.pm, avg 44µs/call
{
1954160115ms416010.4s return $_[0]->smartRead($_[1], $_[2]) == $_[2];
# spent 10.4s making 4160 calls to IO::Uncompress::Base::smartRead, avg 2.50ms/call
196}
197
198sub smartEof
199
# spent 23.0ms (6.34+16.7) within IO::Uncompress::Base::smartEof which was called 223 times, avg 103µs/call: # 182 times (6.08ms+16.6ms) by IO::Uncompress::Base::_raw_read at line 913, avg 125µs/call # 41 times (267µs+35µs) by IO::Uncompress::Base::_raw_read at line 967, avg 7µs/call
{
200223224µs my ($self) = $_[0];
201223833µs local $.;
202
203223542µs return 0 if length *$self->{Prime} || *$self->{PushMode};
204
205183173µs if (defined *$self->{FH})
206 {
207 # Could use
208 #
209 # *$self->{FH}->eof()
210 #
211 # here, but this can cause trouble if
212 # the filehandle is itself a tied handle, but it uses sysread.
213 # Then we get into mixing buffered & non-buffered IO,
214 # which will cause trouble
215
216183585µs183839µs my $info = $self->getErrInfo();
# spent 839µs making 183 calls to IO::Uncompress::Base::getErrInfo, avg 5µs/call
217
218183152µs my $buffer = '';
219183532µs18313.4ms my $status = $self->smartRead(\$buffer, 1);
# spent 13.4ms making 183 calls to IO::Uncompress::Base::smartRead, avg 73µs/call
220183553µs1781.47ms $self->pushBack($buffer) if length $buffer;
# spent 1.47ms making 178 calls to IO::Uncompress::Base::pushBack, avg 8µs/call
221183555µs183966µs $self->setErrInfo($info);
# spent 966µs making 183 calls to IO::Uncompress::Base::setErrInfo, avg 5µs/call
222
2231831.11ms return $status == 0 ;
224 }
225 elsif (defined *$self->{InputEvent})
226 { *$self->{EventEof} }
227 else
228 { *$self->{BufferOffset} >= length(${ *$self->{Buffer} }) }
229}
230
231sub clearError
232{
233 my $self = shift ;
234
235 *$self->{ErrorNo} = 0 ;
236 ${ *$self->{Error} } = '' ;
237}
238
239sub getErrInfo
240
# spent 839µs within IO::Uncompress::Base::getErrInfo which was called 183 times, avg 5µs/call: # 183 times (839µs+0s) by IO::Uncompress::Base::smartEof at line 216, avg 5µs/call
{
241183148µs my $self = shift ;
242
2431831.41ms return [ *$self->{ErrorNo}, ${ *$self->{Error} } ] ;
244}
245
246sub setErrInfo
247
# spent 966µs within IO::Uncompress::Base::setErrInfo which was called 183 times, avg 5µs/call: # 183 times (966µs+0s) by IO::Uncompress::Base::smartEof at line 221, avg 5µs/call
{
248183139µs my $self = shift ;
249183132µs my $ref = shift;
250
251183207µs *$self->{ErrorNo} = $ref->[0] ;
252183630µs ${ *$self->{Error} } = $ref->[1] ;
253}
254
255sub saveStatus
256
# spent 27.6ms within IO::Uncompress::Base::saveStatus which was called 4667 times, avg 6µs/call: # 4445 times (26.4ms+0s) by IO::Uncompress::Base::smartRead at line 108, avg 6µs/call # 182 times (996µs+0s) by IO::Uncompress::Base::_raw_read at line 919, avg 5µs/call # 40 times (231µs+0s) by IO::Uncompress::Base::_create at line 525, avg 6µs/call
{
25746673.62ms my $self = shift ;
25846674.26ms my $errno = shift() + 0 ;
259
26046674.07ms *$self->{ErrorNo} = $errno;
26146674.33ms ${ *$self->{Error} } = '' ;
262
263466722.8ms return *$self->{ErrorNo} ;
264}
265
266
267sub saveErrorString
268{
269 my $self = shift ;
270 my $retval = shift ;
271
272 ${ *$self->{Error} } = shift ;
273 *$self->{ErrorNo} = @_ ? shift() + 0 : STATUS_ERROR ;
274
275 return $retval;
276}
277
278sub croakError
279{
280 my $self = shift ;
281 $self->saveErrorString(0, $_[0]);
282 croak $_[0];
283}
284
285
286sub closeError
287{
288 my $self = shift ;
289 my $retval = shift ;
290
291 my $errno = *$self->{ErrorNo};
292 my $error = ${ *$self->{Error} };
293
294 $self->close();
295
296 *$self->{ErrorNo} = $errno ;
297 ${ *$self->{Error} } = $error ;
298
299 return $retval;
300}
301
302sub error
303{
304 my $self = shift ;
305 return ${ *$self->{Error} } ;
306}
307
308sub errorNo
309{
310 my $self = shift ;
311 return *$self->{ErrorNo};
312}
313
314sub HeaderError
315{
316 my ($self) = shift;
317 return $self->saveErrorString(undef, "Header Error: $_[0]", STATUS_ERROR);
318}
319
320sub TrailerError
321{
322 my ($self) = shift;
323 return $self->saveErrorString(G_ERR, "Trailer Error: $_[0]", STATUS_ERROR);
324}
325
326sub TruncatedHeader
327{
328 my ($self) = shift;
329 return $self->HeaderError("Truncated in $_[0] Section");
330}
331
332sub TruncatedTrailer
333{
334 my ($self) = shift;
335 return $self->TrailerError("Truncated in $_[0] Section");
336}
337
338sub postCheckParams
339
# spent 219µs within IO::Uncompress::Base::postCheckParams which was called 40 times, avg 5µs/call: # 40 times (219µs+0s) by IO::Uncompress::Base::checkParams at line 377, avg 5µs/call
{
34040196µs return 1;
341}
342
343sub checkParams
344
# spent 144ms (20.5+123) within IO::Uncompress::Base::checkParams which was called 40 times, avg 3.59ms/call: # 40 times (20.5ms+123ms) by IO::Uncompress::Base::_create at line 397, avg 3.59ms/call
{
3454049µs my $self = shift ;
34640479µs my $class = shift ;
347
34840739µs403.36ms my $got = shift || IO::Compress::Base::Parameters::new();
# spent 3.36ms making 40 calls to IO::Compress::Base::Parameters::new, avg 84µs/call
349
350409.50ms401.05ms my $Valid = {
# spent 1.05ms making 40 calls to IO::Uncompress::Gunzip::getExtraParams, avg 26µs/call
351 'blocksize' => [IO::Compress::Base::Common::Parse_unsigned, 16 * 1024],
352 'autoclose' => [IO::Compress::Base::Common::Parse_boolean, 0],
353 'strict' => [IO::Compress::Base::Common::Parse_boolean, 0],
354 'append' => [IO::Compress::Base::Common::Parse_boolean, 0],
355 'prime' => [IO::Compress::Base::Common::Parse_any, undef],
356 'multistream' => [IO::Compress::Base::Common::Parse_boolean, 0],
357 'transparent' => [IO::Compress::Base::Common::Parse_any, 1],
358 'scan' => [IO::Compress::Base::Common::Parse_boolean, 0],
359 'inputlength' => [IO::Compress::Base::Common::Parse_unsigned, undef],
360 'binmodeout' => [IO::Compress::Base::Common::Parse_boolean, 0],
361 #'decode' => [IO::Compress::Base::Common::Parse_any, undef],
362
363 #'consumeinput' => [IO::Compress::Base::Common::Parse_boolean, 0],
364
365 $self->getExtraParams(),
366
367 #'Todo - Revert to ordinary file on end Z_STREAM_END'=> 0,
368 # ContinueAfterEof
369 } ;
370
371 $Valid->{trailingdata} = [IO::Compress::Base::Common::Parse_writable_scalar, undef]
3724077µs if *$self->{OneShot} ;
373
374401.24ms40118ms $got->parse($Valid, @_ )
# spent 118ms making 40 calls to IO::Compress::Base::Parameters::parse, avg 2.96ms/call
375 or $self->croakError("${class}: " . $got->getError()) ;
376
37740291µs40219µs $self->postCheckParams($got)
# spent 219µs making 40 calls to IO::Uncompress::Base::postCheckParams, avg 5µs/call
378 or $self->croakError("${class}: " . $self->error()) ;
379
38040580µs return $got;
381}
382
383sub _create
384
# spent 11.0s (66.6ms+10.9) within IO::Uncompress::Base::_create which was called 40 times, avg 274ms/call: # 40 times (66.6ms+10.9s) by IO::Uncompress::Gunzip::new at line 39 of IO/Uncompress/Gunzip.pm, avg 274ms/call
{
3854056µs my $obj = shift;
3864047µs my $got = shift;
3874038µs my $append_mode = shift ;
388
3894068µs my $class = ref $obj;
3904057µs $obj->croakError("$class: Missing Input parameter")
391 if ! @_ && ! $got ;
392
3934051µs my $inValue = shift ;
394
39540545µs *$obj->{OneShot} = 0 ;
396
397401.03ms40144ms if (! $got)
# spent 144ms making 40 calls to IO::Uncompress::Base::checkParams, avg 3.59ms/call
398 {
399 $got = $obj->checkParams($class, undef, @_)
400 or return undef ;
401 }
402
403401.24ms404.17ms my $inType = whatIsInput($inValue, 1);
# spent 4.17ms making 40 calls to IO::Compress::Base::Common::whatIsInput, avg 104µs/call
404
40540567µs402.45ms $obj->ckInputParam($class, $inValue, 1)
# spent 2.45ms making 40 calls to IO::Uncompress::Base::ckInputParam, avg 61µs/call
406 or return undef ;
407
40840500µs *$obj->{InNew} = 1;
409
410 $obj->ckParams($got)
41140188µs401.91ms or $obj->croakError("${class}: " . *$obj->{Error});
# spent 1.91ms making 40 calls to IO::Uncompress::Gunzip::ckParams, avg 48µs/call
412
41340115µs if ($inType eq 'buffer' || $inType eq 'code') {
414 *$obj->{Buffer} = $inValue ;
415 *$obj->{InputEvent} = $inValue
416 if $inType eq 'code' ;
417 }
418 else {
4194091µs if ($inType eq 'handle') {
42040517µs *$obj->{FH} = $inValue ;
4214062µs *$obj->{Handle} = 1 ;
422
423 # Need to rewind for Scan
42440210µs40198µs *$obj->{FH}->seek(0, SEEK_SET)
# spent 198µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 5µs/call
425 if $got->getValue('scan');
426 }
427 else {
42824.15ms246µs
# spent 30µs (13+17) within IO::Uncompress::Base::BEGIN@428 which was called: # once (13µs+17µs) by IO::Uncompress::RawInflate::BEGIN@11 at line 428
no warnings ;
# spent 30µs making 1 call to IO::Uncompress::Base::BEGIN@428 # spent 17µs making 1 call to warnings::unimport
429 my $mode = '<';
430 $mode = '+<' if $got->getValue('scan');
431 *$obj->{StdIO} = ($inValue eq '-');
432 *$obj->{FH} = new IO::File "$mode $inValue"
433 or return $obj->saveErrorString(undef, "cannot open file '$inValue': $!", $!) ;
434 }
435
436402.08ms *$obj->{LineNo} = $. = 0;
43740312µs40563µs setBinModeInput(*$obj->{FH}) ;
# spent 563µs making 40 calls to IO::Compress::Base::Common::setBinModeInput, avg 14µs/call
438
43940611µs my $buff = "" ;
440409.40ms *$obj->{Buffer} = \$buff ;
441 }
442
443# if ($got->getValue('decode')) {
444# my $want_encoding = $got->getValue('decode');
445# *$obj->{Encoding} = IO::Compress::Base::Common::getEncoding($obj, $class, $want_encoding);
446# }
447# else {
448# *$obj->{Encoding} = undef;
449# }
450
451401.11ms40600µs *$obj->{InputLength} = $got->parsed('inputlength')
# spent 600µs making 40 calls to IO::Compress::Base::Parameters::parsed, avg 15µs/call
452 ? $got->getValue('inputlength')
453 : undef ;
45440582µs40120µs *$obj->{InputLengthRemaining} = $got->getValue('inputlength');
# spent 120µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
4554063µs *$obj->{BufferOffset} = 0 ;
456403.55ms40113µs *$obj->{AutoClose} = $got->getValue('autoclose');
# spent 113µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
45740248µs40134µs *$obj->{Strict} = $got->getValue('strict');
# spent 134µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
45840542µs40159µs *$obj->{BlockSize} = $got->getValue('blocksize');
# spent 159µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 4µs/call
459401.55ms40118µs *$obj->{Append} = $got->getValue('append');
# spent 118µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
46040709µs40107µs *$obj->{AppendOutput} = $append_mode || $got->getValue('append');
# spent 107µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
46140581µs40616µs *$obj->{ConsumeInput} = $got->getValue('consumeinput');
# spent 616µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 15µs/call
46240171µs40114µs *$obj->{Transparent} = $got->getValue('transparent');
# spent 114µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
46340169µs40110µs *$obj->{MultiStream} = $got->getValue('multistream');
# spent 110µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
464
465 # TODO - move these two into RawDeflate
46640165µs40106µs *$obj->{Scan} = $got->getValue('scan');
# spent 106µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
46740287µs80217µs *$obj->{ParseExtra} = $got->getValue('parseextra')
# spent 217µs making 80 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
468 || $got->getValue('strict') ;
4694069µs *$obj->{Type} = '';
47040624µs40115µs *$obj->{Prime} = $got->getValue('prime') || '' ;
# spent 115µs making 40 calls to IO::Compress::Base::Parameters::getValue, avg 3µs/call
47140468µs *$obj->{Pending} = '';
47240467µs *$obj->{Plain} = 0;
4734061µs *$obj->{PlainBytesRead} = 0;
4744062µs *$obj->{InflatedBytesRead} = 0;
475401.18ms401.07ms *$obj->{UnCompSize} = new U64;
# spent 1.07ms making 40 calls to U64::new, avg 27µs/call
47640172µs40143µs *$obj->{CompSize} = new U64;
# spent 143µs making 40 calls to U64::new, avg 4µs/call
4774054µs *$obj->{TotalInflatedBytesRead} = 0;
478401.31ms *$obj->{NewStream} = 0 ;
4794058µs *$obj->{EventEof} = 0 ;
4804068µs *$obj->{ClassName} = $class ;
48140460µs *$obj->{Params} = $got ;
482
4834057µs if (*$obj->{ConsumeInput}) {
484 *$obj->{InNew} = 0;
485 *$obj->{Closed} = 0;
486 return $obj
487 }
488
489401.41ms4010.7s my $status = $obj->mkUncomp($got);
# spent 10.7s making 40 calls to IO::Uncompress::RawInflate::mkUncomp, avg 267ms/call
490
491 return undef
4924039µs unless defined $status;
493
4944067µs *$obj->{InNew} = 0;
4954066µs *$obj->{Closed} = 0;
496
4974075µs if ($status) {
498 # Need to try uncompressing to catch the case
499 # where the compressed file uncompresses to an
500 # empty string - so eof is set immediately.
501
50240230µs my $out_buffer = '';
503
50440413µs4026.9ms $status = $obj->read(\$out_buffer);
# spent 26.9ms making 40 calls to IO::Uncompress::Base::read, avg 673µs/call
505
5064038µs if ($status < 0) {
507 *$obj->{ReadStatus} = [ $status, $obj->error(), $obj->errorNo() ];
508 }
509
51040403µs403.86ms $obj->ungetc($out_buffer)
# spent 3.86ms making 40 calls to IO::Uncompress::Base::ungetc, avg 97µs/call
511 if length $out_buffer;
512 }
513 else {
514 return undef
515 unless *$obj->{Transparent};
516
517 $obj->clearError();
518 *$obj->{Type} = 'plain';
519 *$obj->{Plain} = 1;
520 $obj->pushBack(*$obj->{HeaderPending}) ;
521 }
522
52340144µs push @{ *$obj->{InfoList} }, *$obj->{Info} ;
524
52540133µs40231µs $obj->saveStatus(STATUS_OK) ;
# spent 231µs making 40 calls to IO::Uncompress::Base::saveStatus, avg 6µs/call
5264052µs *$obj->{InNew} = 0;
5274048µs *$obj->{Closed} = 0;
528
52940687µs return $obj;
530}
531
532sub ckInputParam
533
# spent 2.45ms (1.39+1.05) within IO::Uncompress::Base::ckInputParam which was called 40 times, avg 61µs/call: # 40 times (1.39ms+1.05ms) by IO::Uncompress::Base::_create at line 405, avg 61µs/call
{
5344051µs my $self = shift ;
5354050µs my $from = shift ;
53640694µs401.05ms my $inType = whatIsInput($_[0], $_[1]);
# spent 1.05ms making 40 calls to IO::Compress::Base::Common::whatIsInput, avg 26µs/call
537
5384040µs $self->croakError("$from: input parameter not a filename, filehandle, array ref or scalar ref")
539 if ! $inType ;
540
541# if ($inType eq 'filename' )
542# {
543# return $self->saveErrorString(1, "$from: input filename is undef or null string", STATUS_ERROR)
544# if ! defined $_[0] || $_[0] eq '' ;
545#
546# if ($_[0] ne '-' && ! -e $_[0] )
547# {
548# return $self->saveErrorString(1,
549# "input file '$_[0]' does not exist", STATUS_ERROR);
550# }
551# }
552
55340190µs return 1;
554}
555
556
557sub _inf
558{
559 my $obj = shift ;
560
561 my $class = (caller)[0] ;
562 my $name = (caller(1))[3] ;
563
564 $obj->croakError("$name: expected at least 1 parameters\n")
565 unless @_ >= 1 ;
566
567 my $input = shift ;
568 my $haveOut = @_ ;
569 my $output = shift ;
570
571
572 my $x = new IO::Compress::Base::Validator($class, *$obj->{Error}, $name, $input, $output)
573 or return undef ;
574
575 push @_, $output if $haveOut && $x->{Hash};
576
577 *$obj->{OneShot} = 1 ;
578
579 my $got = $obj->checkParams($name, undef, @_)
580 or return undef ;
581
582 if ($got->parsed('trailingdata'))
583 {
584# my $value = $got->valueRef('TrailingData');
585# warn "TD $value ";
586# #$value = $$value;
587## warn "TD $value $$value ";
588#
589# return retErr($obj, "Parameter 'TrailingData' not writable")
590# if readonly $$value ;
591#
592# if (ref $$value)
593# {
594# return retErr($obj,"Parameter 'TrailingData' not a scalar reference")
595# if ref $$value ne 'SCALAR' ;
596#
597# *$obj->{TrailingData} = $$value ;
598# }
599# else
600# {
601# return retErr($obj,"Parameter 'TrailingData' not a scalar")
602# if ref $value ne 'SCALAR' ;
603#
604# *$obj->{TrailingData} = $value ;
605# }
606
607 *$obj->{TrailingData} = $got->getValue('trailingdata');
608 }
609
610 *$obj->{MultiStream} = $got->getValue('multistream');
611 $got->setValue('multistream', 0);
612
613 $x->{Got} = $got ;
614
615# if ($x->{Hash})
616# {
617# while (my($k, $v) = each %$input)
618# {
619# $v = \$input->{$k}
620# unless defined $v ;
621#
622# $obj->_singleTarget($x, $k, $v, @_)
623# or return undef ;
624# }
625#
626# return keys %$input ;
627# }
628
629 if ($x->{GlobMap})
630 {
631 $x->{oneInput} = 1 ;
632 foreach my $pair (@{ $x->{Pairs} })
633 {
634 my ($from, $to) = @$pair ;
635 $obj->_singleTarget($x, $from, $to, @_)
636 or return undef ;
637 }
638
639 return scalar @{ $x->{Pairs} } ;
640 }
641
642 if (! $x->{oneOutput} )
643 {
644 my $inFile = ($x->{inType} eq 'filenames'
645 || $x->{inType} eq 'filename');
646
647 $x->{inType} = $inFile ? 'filename' : 'buffer';
648
649 foreach my $in ($x->{oneInput} ? $input : @$input)
650 {
651 my $out ;
652 $x->{oneInput} = 1 ;
653
654 $obj->_singleTarget($x, $in, $output, @_)
655 or return undef ;
656 }
657
658 return 1 ;
659 }
660
661 # finally the 1 to 1 and n to 1
662 return $obj->_singleTarget($x, $input, $output, @_);
663
664 croak "should not be here" ;
665}
666
667sub retErr
668{
669 my $x = shift ;
670 my $string = shift ;
671
672 ${ $x->{Error} } = $string ;
673
674 return undef ;
675}
676
677sub _singleTarget
678{
679 my $self = shift ;
680 my $x = shift ;
681 my $input = shift;
682 my $output = shift;
683
684 my $buff = '';
685 $x->{buff} = \$buff ;
686
687 my $fh ;
688 if ($x->{outType} eq 'filename') {
689 my $mode = '>' ;
690 $mode = '>>'
691 if $x->{Got}->getValue('append') ;
692 $x->{fh} = new IO::File "$mode $output"
693 or return retErr($x, "cannot open file '$output': $!") ;
694 binmode $x->{fh} if $x->{Got}->valueOrDefault('binmodeout');
695
696 }
697
698 elsif ($x->{outType} eq 'handle') {
699 $x->{fh} = $output;
700 binmode $x->{fh} if $x->{Got}->valueOrDefault('binmodeout');
701 if ($x->{Got}->getValue('append')) {
702 seek($x->{fh}, 0, SEEK_END)
703 or return retErr($x, "Cannot seek to end of output filehandle: $!") ;
704 }
705 }
706
707
708 elsif ($x->{outType} eq 'buffer' )
709 {
710 $$output = ''
711 unless $x->{Got}->getValue('append');
712 $x->{buff} = $output ;
713 }
714
715 if ($x->{oneInput})
716 {
717 defined $self->_rd2($x, $input, $output)
718 or return undef;
719 }
720 else
721 {
722 for my $element ( ($x->{inType} eq 'hash') ? keys %$input : @$input)
723 {
724 defined $self->_rd2($x, $element, $output)
725 or return undef ;
726 }
727 }
728
729
730 if ( ($x->{outType} eq 'filename' && $output ne '-') ||
731 ($x->{outType} eq 'handle' && $x->{Got}->getValue('autoclose'))) {
732 $x->{fh}->close()
733 or return retErr($x, $!);
734 delete $x->{fh};
735 }
736
737 return 1 ;
738}
739
740sub _rd2
741{
742 my $self = shift ;
743 my $x = shift ;
744 my $input = shift;
745 my $output = shift;
746
747 my $z = IO::Compress::Base::Common::createSelfTiedObject($x->{Class}, *$self->{Error});
748
749 $z->_create($x->{Got}, 1, $input, @_)
750 or return undef ;
751
752 my $status ;
753 my $fh = $x->{fh};
754
755 while (1) {
756
757 while (($status = $z->read($x->{buff})) > 0) {
758 if ($fh) {
759 local $\;
760 print $fh ${ $x->{buff} }
761 or return $z->saveErrorString(undef, "Error writing to output file: $!", $!);
762 ${ $x->{buff} } = '' ;
763 }
764 }
765
766 if (! $x->{oneOutput} ) {
767 my $ot = $x->{outType} ;
768
769 if ($ot eq 'array')
770 { push @$output, $x->{buff} }
771 elsif ($ot eq 'hash')
772 { $output->{$input} = $x->{buff} }
773
774 my $buff = '';
775 $x->{buff} = \$buff;
776 }
777
778 last if $status < 0 || $z->smartEof();
779
780 last
781 unless *$self->{MultiStream};
782
783 $status = $z->nextStream();
784
785 last
786 unless $status == 1 ;
787 }
788
789 return $z->closeError(undef)
790 if $status < 0 ;
791
792 ${ *$self->{TrailingData} } = $z->trailingData()
793 if defined *$self->{TrailingData} ;
794
795 $z->close()
796 or return undef ;
797
798 return 1 ;
799}
800
801sub TIEHANDLE
802
# spent 3.16ms within IO::Uncompress::Base::TIEHANDLE which was called 40 times, avg 79µs/call: # 40 times (3.16ms+0s) by IO::Compress::Base::Common::createSelfTiedObject at line 450 of IO/Compress/Base/Common.pm, avg 79µs/call
{
803402.72ms return $_[0] if ref($_[0]);
804 die "OOPS\n" ;
805
806}
807
808sub UNTIE
809
# spent 175µs within IO::Uncompress::Base::UNTIE which was called 40 times, avg 4µs/call: # 40 times (175µs+0s) by IO::Uncompress::Base::close at line 1360, avg 4µs/call
{
81040264µs my $self = shift ;
811}
812
813
814sub getHeaderInfo
815
# spent 197µs within IO::Uncompress::Base::getHeaderInfo which was called 40 times, avg 5µs/call: # 40 times (197µs+0s) by OpenBSD::PackageRepository::uncompress at line 407 of OpenBSD/PackageRepository.pm, avg 5µs/call
{
8164043µs my $self = shift ;
81740235µs wantarray ? @{ *$self->{InfoList} } : *$self->{Info};
818}
819
820sub readBlock
821
# spent 23.1ms (2.04+21.0) within IO::Uncompress::Base::readBlock which was called 182 times, avg 127µs/call: # 182 times (2.04ms+21.0ms) by IO::Uncompress::Base::_raw_read at line 902, avg 127µs/call
{
822182139µs my $self = shift ;
823182133µs my $buff = shift ;
824182139µs my $size = shift ;
825
826182175µs if (defined *$self->{CompressedInputLength}) {
827 if (*$self->{CompressedInputLengthRemaining} == 0) {
828 delete *$self->{CompressedInputLength};
829 *$self->{CompressedInputLengthDone} = 1;
830 return STATUS_OK ;
831 }
832 $size = List::Util::min($size, *$self->{CompressedInputLengthRemaining} );
833 *$self->{CompressedInputLengthRemaining} -= $size ;
834 }
835
836182595µs18221.0ms my $status = $self->smartRead($buff, $size) ;
# spent 21.0ms making 182 calls to IO::Uncompress::Base::smartRead, avg 116µs/call
837182157µs return $self->saveErrorString(STATUS_ERROR, "Error Reading Data: $!", $!)
838 if $status == STATUS_ERROR ;
839
840182136µs if ($status == 0 ) {
841 *$self->{Closed} = 1 ;
842 *$self->{EndStream} = 1 ;
843 return $self->saveErrorString(STATUS_ERROR, "unexpected end of file", STATUS_ERROR);
844 }
845
846182595µs return STATUS_OK;
847}
848
849sub postBlockChk
850
# spent 373µs within IO::Uncompress::Base::postBlockChk which was called 182 times, avg 2µs/call: # 182 times (373µs+0s) by IO::Uncompress::Base::_raw_read at line 921, avg 2µs/call
{
851182636µs return STATUS_OK;
852}
853
854sub _raw_read
855
# spent 131ms (45.0+85.6) within IO::Uncompress::Base::_raw_read which was called 222 times, avg 588µs/call: # 182 times (38.4ms+67.9ms) by IO::Uncompress::Base::read at line 1173, avg 584µs/call # 40 times (6.64ms+17.6ms) by IO::Uncompress::Base::read at line 1160, avg 607µs/call
{
856 # return codes
857 # >0 - ok, number of bytes read
858 # =0 - ok, eof
859 # <0 - not ok
860
861222223µs my $self = shift ;
862
863222225µs return G_EOF if *$self->{Closed} ;
864222187µs return G_EOF if *$self->{EndStream} ;
865
866222307µs my $buffer = shift ;
867222180µs my $scan_mode = shift ;
868
869222223µs if (*$self->{Plain}) {
870 my $tmp_buff ;
871 my $len = $self->smartRead(\$tmp_buff, *$self->{BlockSize}) ;
872
873 return $self->saveErrorString(G_ERR, "Error reading data: $!", $!)
874 if $len == STATUS_ERROR ;
875
876 if ($len == 0 ) {
877 *$self->{EndStream} = 1 ;
878 }
879 else {
880 *$self->{PlainBytesRead} += $len ;
881 $$buffer .= $tmp_buff;
882 }
883
884 return $len ;
885 }
886
887222199µs if (*$self->{NewStream}) {
888
88940173µs408.04ms $self->gotoNextStream() > 0
# spent 8.04ms making 40 calls to IO::Uncompress::Base::gotoNextStream, avg 201µs/call
890 or return G_ERR;
891
892 # For the headers that actually uncompressed data, put the
893 # uncompressed data into the output buffer.
8944062µs $$buffer .= *$self->{Pending} ;
8954047µs my $len = length *$self->{Pending} ;
8964045µs *$self->{Pending} = '';
89740147µs return $len;
898 }
899
900182450µs my $temp_buf = '';
901182133µs my $outSize = 0;
902182678µs18223.1ms my $status = $self->readBlock(\$temp_buf, *$self->{BlockSize}, $outSize) ;
# spent 23.1ms making 182 calls to IO::Uncompress::Base::readBlock, avg 127µs/call
903
904182129µs return G_ERR
905 if $status == STATUS_ERROR ;
906
907182143µs my $buf_len = 0;
908182275µs if ($status == STATUS_OK) {
909182144µs my $beforeC_len = length $temp_buf;
910182190µs my $before_len = defined $$buffer ? length $$buffer : 0 ;
911 $status = *$self->{Uncomp}->uncompr(\$temp_buf, $buffer,
912 defined *$self->{CompressedInputLengthDone} ||
9131821.52ms36444.4ms $self->smartEof(), $outSize);
# spent 22.7ms making 182 calls to IO::Uncompress::Base::smartEof, avg 125µs/call # spent 21.7ms making 182 calls to IO::Uncompress::Adapter::Inflate::uncompr, avg 119µs/call
914
915 # Remember the input buffer if it wasn't consumed completely
916182619µs1823.68ms $self->pushBack($temp_buf) if *$self->{Uncomp}{ConsumesInput};
# spent 3.68ms making 182 calls to IO::Uncompress::Base::pushBack, avg 20µs/call
917
918 return $self->saveErrorString(G_ERR, *$self->{Uncomp}{Error}, *$self->{Uncomp}{ErrorNo})
919182602µs182996µs if $self->saveStatus($status) == STATUS_ERROR;
# spent 996µs making 182 calls to IO::Uncompress::Base::saveStatus, avg 5µs/call
920
921182695µs182373µs $self->postBlockChk($buffer, $before_len) == STATUS_OK
# spent 373µs making 182 calls to IO::Uncompress::Base::postBlockChk, avg 2µs/call
922 or return G_ERR;
923
924182204µs $buf_len = defined $$buffer ? length($$buffer) - $before_len : 0;
925
9261821.38ms1821.61ms *$self->{CompSize}->add($beforeC_len - length $temp_buf) ;
# spent 1.61ms making 182 calls to U64::add, avg 9µs/call
927
928182180µs *$self->{InflatedBytesRead} += $buf_len ;
929182173µs *$self->{TotalInflatedBytesRead} += $buf_len ;
930182514µs182990µs *$self->{UnCompSize}->add($buf_len) ;
# spent 990µs making 182 calls to U64::add, avg 5µs/call
931
932182966µs182694µs $self->filterUncompressed($buffer, $before_len);
# spent 694µs making 182 calls to IO::Uncompress::Base::filterUncompressed, avg 4µs/call
933
934# if (*$self->{Encoding}) {
935# use Encode ;
936# *$self->{PendingDecode} .= substr($$buffer, $before_len) ;
937# my $got = *$self->{Encoding}->decode(*$self->{PendingDecode}, Encode::FB_QUIET) ;
938# substr($$buffer, $before_len) = $got;
939# }
940 }
941
942182152µs if ($status == STATUS_ENDSTREAM) {
943
9444160µs *$self->{EndStream} = 1 ;
945
9464138µs my $trailer;
9474159µs my $trailer_size = *$self->{Info}{TrailerLength} ;
9484135µs my $got = 0;
94941340µs41688µs if (*$self->{Info}{TrailerLength})
# spent 688µs making 41 calls to IO::Uncompress::Base::smartRead, avg 17µs/call
950 {
951 $got = $self->smartRead(\$trailer, $trailer_size) ;
952 }
953
95441178µs41663µs if ($got == $trailer_size) {
# spent 663µs making 41 calls to IO::Uncompress::Gunzip::chkTrailer, avg 16µs/call
955 $self->chkTrailer($trailer) == STATUS_OK
956 or return G_ERR;
957 }
958 else {
959 return $self->TrailerError("trailer truncated. Expected " .
960 "$trailer_size bytes, got $got")
961 if *$self->{Strict};
962 $self->pushBack($trailer) ;
963 }
964
965 # TODO - if want file pointer, do it here
966
96741208µs41302µs if (! $self->smartEof()) {
# spent 302µs making 41 calls to IO::Uncompress::Base::smartEof, avg 7µs/call
9684052µs *$self->{NewStream} = 1 ;
969
9704049µs if (*$self->{MultiStream}) {
9714044µs *$self->{EndStream} = 0 ;
97240172µs return $buf_len ;
973 }
974 }
975
976 }
977
978
979 # return the number of uncompressed bytes read
9801422.92ms return $buf_len ;
981}
982
983sub reset
984
# spent 888µs (352+536) within IO::Uncompress::Base::reset which was called 40 times, avg 22µs/call: # 40 times (352µs+536µs) by IO::Uncompress::Base::gotoNextStream at line 1036, avg 22µs/call
{
9854041µs my $self = shift ;
986
98740299µs40536µs return *$self->{Uncomp}->reset();
# spent 536µs making 40 calls to IO::Uncompress::Adapter::Inflate::reset, avg 13µs/call
988}
989
990sub filterUncompressed
991182570µs
# spent 694µs within IO::Uncompress::Base::filterUncompressed which was called 182 times, avg 4µs/call: # 182 times (694µs+0s) by IO::Uncompress::Base::_raw_read at line 932, avg 4µs/call
{
992}
993
994#sub isEndStream
995#{
996# my $self = shift ;
997# return *$self->{NewStream} ||
998# *$self->{EndStream} ;
999#}
1000
1001sub nextStream
1002{
1003 my $self = shift ;
1004
1005 my $status = $self->gotoNextStream();
1006 $status == 1
1007 or return $status ;
1008
1009 *$self->{TotalInflatedBytesRead} = 0 ;
1010 *$self->{LineNo} = $. = 0;
1011
1012 return 1;
1013}
1014
1015sub gotoNextStream
1016
# spent 8.04ms (1.84+6.21) within IO::Uncompress::Base::gotoNextStream which was called 40 times, avg 201µs/call: # 40 times (1.84ms+6.21ms) by IO::Uncompress::Base::_raw_read at line 889, avg 201µs/call
{
10174039µs my $self = shift ;
1018
10194053µs if (! *$self->{NewStream}) {
1020 my $status = 1;
1021 my $buffer ;
1022
1023 # TODO - make this more efficient if know the offset for the end of
1024 # the stream and seekable
1025 $status = $self->read($buffer)
1026 while $status > 0 ;
1027
1028 return $status
1029 if $status < 0;
1030 }
1031
10324050µs *$self->{NewStream} = 0 ;
10334047µs *$self->{EndStream} = 0 ;
10344070µs *$self->{CompressedInputLengthDone} = undef ;
10354045µs *$self->{CompressedInputLength} = undef ;
103640139µs40888µs $self->reset();
# spent 888µs making 40 calls to IO::Uncompress::Base::reset, avg 22µs/call
103740170µs40149µs *$self->{UnCompSize}->reset();
# spent 149µs making 40 calls to U64::reset, avg 4µs/call
103840120µs4075µs *$self->{CompSize}->reset();
# spent 75µs making 40 calls to U64::reset, avg 2µs/call
1039
104040184µs402.27ms my $magic = $self->ckMagic();
# spent 2.27ms making 40 calls to IO::Uncompress::Gunzip::ckMagic, avg 57µs/call
1041
10424079µs if ( ! defined $magic) {
1043 if (! *$self->{Transparent} || $self->eof())
1044 {
1045 *$self->{EndStream} = 1 ;
1046 return 0;
1047 }
1048
1049 $self->clearError();
1050 *$self->{Type} = 'plain';
1051 *$self->{Plain} = 1;
1052 $self->pushBack(*$self->{HeaderPending}) ;
1053 }
1054 else
1055 {
105640159µs402.83ms *$self->{Info} = $self->readHeader($magic);
# spent 2.83ms making 40 calls to IO::Uncompress::Gunzip::readHeader, avg 71µs/call
1057
10584068µs if ( ! defined *$self->{Info} ) {
1059 *$self->{EndStream} = 1 ;
1060 return -1;
1061 }
1062 }
1063
10644084µs push @{ *$self->{InfoList} }, *$self->{Info} ;
1065
106640161µs return 1;
1067}
1068
1069sub streamCount
1070{
1071 my $self = shift ;
1072 return 1 if ! defined *$self->{InfoList};
1073 return scalar @{ *$self->{InfoList} } ;
1074}
1075
1076#sub read
1077#{
1078# my $status = myRead(@_);
1079# return undef if $status < 0;
1080# return $status;
1081#}
1082
1083sub read
1084
# spent 150ms (19.3+131) within IO::Uncompress::Base::read which was called 321 times, avg 469µs/call: # 122 times (5.88ms+35.5ms) by OpenBSD::Ustar::CORE:read at line 188 of OpenBSD/Ustar.pm, avg 339µs/call # 79 times (3.07ms+141µs) by OpenBSD::Ustar::CORE:read at line 113 of OpenBSD/Ustar.pm, avg 41µs/call # 40 times (5.60ms+71.0ms) by OpenBSD::Ustar::File::CORE:read at line 868 of OpenBSD/Ustar.pm, avg 1.92ms/call # 40 times (2.49ms+24.4ms) by IO::Uncompress::Base::_create at line 504, avg 673µs/call # 40 times (2.28ms+73µs) by OpenBSD::Ustar::File::CORE:read at line 829 of OpenBSD/Ustar.pm, avg 59µs/call
{
1085 # return codes
1086 # >0 - ok, number of bytes read
1087 # =0 - ok, eof
1088 # <0 - not ok
1089
1090321274µs my $self = shift ;
1091
1092321393µs if (defined *$self->{ReadStatus} ) {
1093 my $status = *$self->{ReadStatus}[0];
1094 $self->saveErrorString( @{ *$self->{ReadStatus} } );
1095 delete *$self->{ReadStatus} ;
1096 return $status ;
1097 }
1098
1099321293µs return G_EOF if *$self->{Closed} ;
1100
1101321245µs my $buffer ;
1102
1103321564µs if (ref $_[0] ) {
1104 $self->croakError(*$self->{ClassName} . "::read: buffer parameter is read-only")
110540360µs40151µs if Scalar::Util::readonly(${ $_[0] });
# spent 151µs making 40 calls to Scalar::Util::readonly, avg 4µs/call
1106
11074067µs $self->croakError(*$self->{ClassName} . "::read: not a scalar reference $_[0]" )
1108 unless ref $_[0] eq 'SCALAR' ;
11094043µs $buffer = $_[0] ;
1110 }
1111 else {
11122811.51ms281471µs $self->croakError(*$self->{ClassName} . "::read: buffer parameter is read-only")
# spent 471µs making 281 calls to Scalar::Util::readonly, avg 2µs/call
1113 if Scalar::Util::readonly($_[0]);
1114
1115281285µs $buffer = \$_[0] ;
1116 }
1117
1118321272µs my $length = $_[1] ;
1119321270µs my $offset = $_[2] || 0;
1120
1121321531µs if (! *$self->{AppendOutput}) {
1122321906µs if (! $offset) {
1123321790µs $$buffer = '' ;
1124 }
1125 else {
1126 if ($offset > length($$buffer)) {
1127 $$buffer .= "\x00" x ($offset - length($$buffer));
1128 }
1129 else {
1130 substr($$buffer, $offset) = '';
1131 }
1132 }
1133 }
1134 elsif (! defined $$buffer) {
1135 $$buffer = '' ;
1136 }
1137
1138321619µs return G_EOF if !length *$self->{Pending} && *$self->{EndStream} ;
1139
1140 # the core read will return 0 if asked for 0 bytes
1141320279µs return 0 if defined $length && $length == 0 ;
1142
1143320267µs $length = $length || 0;
1144
1145320258µs $self->croakError(*$self->{ClassName} . "::read: length parameter is negative")
1146 if $length < 0 ;
1147
1148 # Short-circuit if this is a simple read, with no length
1149 # or offset specified.
1150320234µs unless ( $length || $offset) {
11514059µs if (length *$self->{Pending}) {
1152 $$buffer .= *$self->{Pending} ;
1153 my $len = length *$self->{Pending};
1154 *$self->{Pending} = '' ;
1155 return $len ;
1156 }
1157 else {
11584038µs my $len = 0;
1159 $len = $self->_raw_read($buffer)
116040689µs4024.3ms while ! *$self->{EndStream} && $len == 0 ;
# spent 24.3ms making 40 calls to IO::Uncompress::Base::_raw_read, avg 607µs/call
116140185µs return $len ;
1162 }
1163 }
1164
1165 # Need to jump through more hoops - either length or offset
1166 # or both are specified.
11672801.80ms my $out_buffer = *$self->{Pending} ;
1168280299µs *$self->{Pending} = '';
1169
1170
1171280531µs while (! *$self->{EndStream} && length($out_buffer) < $length)
1172 {
1173182598µs182106ms my $buf_len = $self->_raw_read(\$out_buffer);
# spent 106ms making 182 calls to IO::Uncompress::Base::_raw_read, avg 584µs/call
1174182366µs return $buf_len
1175 if $buf_len < 0 ;
1176 }
1177
1178280234µs $length = length $out_buffer
1179 if length($out_buffer) < $length ;
1180
1181280224µs return 0
1182 if $length == 0 ;
1183
1184280222µs $$buffer = ''
1185 if ! defined $$buffer;
1186
1187 $offset = length $$buffer
1188280236µs if *$self->{AppendOutput} ;
1189
11902803.15ms *$self->{Pending} = $out_buffer;
1191280446µs $out_buffer = \*$self->{Pending} ;
1192
11932801.36ms substr($$buffer, $offset) = substr($$out_buffer, 0, $length) ;
1194280301µs substr($$out_buffer, 0, $length) = '' ;
1195
11962801.18ms return $length ;
1197}
1198
1199sub _getline
1200{
1201 my $self = shift ;
1202 my $status = 0 ;
1203
1204 # Slurp Mode
1205 if ( ! defined $/ ) {
1206 my $data ;
1207 1 while ($status = $self->read($data)) > 0 ;
1208 return ($status, \$data);
1209 }
1210
1211 # Record Mode
1212 if ( ref $/ eq 'SCALAR' && ${$/} =~ /^\d+$/ && ${$/} > 0) {
1213 my $reclen = ${$/} ;
1214 my $data ;
1215 $status = $self->read($data, $reclen) ;
1216 return ($status, \$data);
1217 }
1218
1219 # Paragraph Mode
1220 if ( ! length $/ ) {
1221 my $paragraph ;
1222 while (($status = $self->read($paragraph)) > 0 ) {
1223 if ($paragraph =~ s/^(.*?\n\n+)//s) {
1224 *$self->{Pending} = $paragraph ;
1225 my $par = $1 ;
1226 return (1, \$par);
1227 }
1228 }
1229 return ($status, \$paragraph);
1230 }
1231
1232 # $/ isn't empty, or a reference, so it's Line Mode.
1233 {
1234 my $line ;
1235 my $p = \*$self->{Pending} ;
1236 while (($status = $self->read($line)) > 0 ) {
1237 my $offset = index($line, $/);
1238 if ($offset >= 0) {
1239 my $l = substr($line, 0, $offset + length $/ );
1240 substr($line, 0, $offset + length $/) = '';
1241 $$p = $line;
1242 return (1, \$l);
1243 }
1244 }
1245
1246 return ($status, \$line);
1247 }
1248}
1249
1250sub getline
1251{
1252 my $self = shift;
1253
1254 if (defined *$self->{ReadStatus} ) {
1255 $self->saveErrorString( @{ *$self->{ReadStatus} } );
1256 delete *$self->{ReadStatus} ;
1257 return undef;
1258 }
1259
1260 return undef
1261 if *$self->{Closed} || (!length *$self->{Pending} && *$self->{EndStream}) ;
1262
1263 my $current_append = *$self->{AppendOutput} ;
1264 *$self->{AppendOutput} = 1;
1265
1266 my ($status, $lineref) = $self->_getline();
1267 *$self->{AppendOutput} = $current_append;
1268
1269 return undef
1270 if $status < 0 || length $$lineref == 0 ;
1271
1272 $. = ++ *$self->{LineNo} ;
1273
1274 return $$lineref ;
1275}
1276
1277sub getlines
1278{
1279 my $self = shift;
1280 $self->croakError(*$self->{ClassName} .
1281 "::getlines: called in scalar context\n") unless wantarray;
1282 my($line, @lines);
1283 push(@lines, $line)
1284 while defined($line = $self->getline);
1285 return @lines;
1286}
1287
1288sub READLINE
1289{
1290 goto &getlines if wantarray;
1291 goto &getline;
1292}
1293
1294sub getc
1295{
1296 my $self = shift;
1297 my $buf;
1298 return $buf if $self->read($buf, 1);
1299 return undef;
1300}
1301
1302sub ungetc
1303
# spent 3.86ms within IO::Uncompress::Base::ungetc which was called 40 times, avg 97µs/call: # 40 times (3.86ms+0s) by IO::Uncompress::Base::_create at line 510, avg 97µs/call
{
13044043µs my $self = shift;
13054075µs *$self->{Pending} = "" unless defined *$self->{Pending} ;
1306403.59ms *$self->{Pending} = $_[0] . *$self->{Pending} ;
1307}
1308
1309
1310sub trailingData
1311{
1312 my $self = shift ;
1313
1314 if (defined *$self->{FH} || defined *$self->{InputEvent} ) {
1315 return *$self->{Prime} ;
1316 }
1317 else {
1318 my $buf = *$self->{Buffer} ;
1319 my $offset = *$self->{BufferOffset} ;
1320 return substr($$buf, $offset) ;
1321 }
1322}
1323
1324
1325sub eof
1326{
1327 my $self = shift ;
1328
1329 return (*$self->{Closed} ||
1330 (!length *$self->{Pending}
1331 && ( $self->smartEof() || *$self->{EndStream}))) ;
1332}
1333
1334sub tell
1335{
1336 my $self = shift ;
1337
1338 my $in ;
1339 if (*$self->{Plain}) {
1340 $in = *$self->{PlainBytesRead} ;
1341 }
1342 else {
1343 $in = *$self->{TotalInflatedBytesRead} ;
1344 }
1345
1346 my $pending = length *$self->{Pending} ;
1347
1348 return 0 if $pending > $in ;
1349 return $in - $pending ;
1350}
1351
1352sub close
1353
# spent 980ms (980+175µs) within IO::Uncompress::Base::close which was called 80 times, avg 12.2ms/call: # 40 times (979ms+175µs) by OpenBSD::PackageRepository::CORE:close at line 208 of OpenBSD/PackageRepository.pm, avg 24.5ms/call # 40 times (193µs+0s) by IO::Uncompress::Base::DESTROY at line 1386, avg 5µs/call
{
1354 # todo - what to do if close is called before the end of the gzip file
1355 # do we remember any trailing data?
135680102µs my $self = shift ;
1357
135880315µs return 1 if *$self->{Closed} ;
1359
136040468µs40175µs untie *$self
# spent 175µs making 40 calls to IO::Uncompress::Base::UNTIE, avg 4µs/call
1361 if $] >= 5.008 ;
1362
13634056µs my $status = 1 ;
1364
136540113µs if (defined *$self->{FH}) {
136640113µs if ((! *$self->{Handle} || *$self->{AutoClose}) && ! *$self->{StdIO}) {
1367 local $.;
1368 $! = 0 ;
1369 $status = *$self->{FH}->close();
1370 return $self->saveErrorString(0, $!, $!)
1371 if !*$self->{InNew} && $self->saveStatus($!) != 0 ;
1372 }
137340974ms delete *$self->{FH} ;
1374403.74ms $! = 0 ;
1375 }
137640123µs *$self->{Closed} = 1 ;
1377
137840454µs return 1;
1379}
1380
1381sub DESTROY
1382
# spent 1.97ms (1.78+193µs) within IO::Uncompress::Base::DESTROY which was called 40 times, avg 49µs/call: # 39 times (1.74ms+188µs) by OpenBSD::PackageLocation::deref at line 285 of OpenBSD/PackageLocation.pm, avg 49µs/call # once (38µs+5µs) by OpenBSD::PackageLocation::deref at line 284 of OpenBSD/PackageLocation.pm
{
13834042µs my $self = shift ;
1384401.24ms local ($., $@, $!, $^E, $?);
1385
138640485µs40193µs $self->close() ;
# spent 193µs making 40 calls to IO::Uncompress::Base::close, avg 5µs/call
1387}
1388
1389sub seek
1390{
1391 my $self = shift ;
1392 my $position = shift;
1393 my $whence = shift ;
1394
1395 my $here = $self->tell() ;
1396 my $target = 0 ;
1397
1398
1399 if ($whence == SEEK_SET) {
1400 $target = $position ;
1401 }
1402 elsif ($whence == SEEK_CUR) {
1403 $target = $here + $position ;
1404 }
1405 elsif ($whence == SEEK_END) {
1406 $target = $position ;
1407 $self->croakError(*$self->{ClassName} . "::seek: SEEK_END not allowed") ;
1408 }
1409 else {
1410 $self->croakError(*$self->{ClassName} ."::seek: unknown value, $whence, for whence parameter");
1411 }
1412
1413 # short circuit if seeking to current offset
1414 if ($target == $here) {
1415 # On ordinary filehandles, seeking to the current
1416 # position also clears the EOF condition, so we
1417 # emulate this behavior locally while simultaneously
1418 # cascading it to the underlying filehandle
1419 if (*$self->{Plain}) {
1420 *$self->{EndStream} = 0;
1421 seek(*$self->{FH},0,1) if *$self->{FH};
1422 }
1423 return 1;
1424 }
1425
1426 # Outlaw any attempt to seek backwards
1427 $self->croakError( *$self->{ClassName} ."::seek: cannot seek backwards")
1428 if $target < $here ;
1429
1430 # Walk the file to the new offset
1431 my $offset = $target - $here ;
1432
1433 my $got;
1434 while (($got = $self->read(my $buffer, List::Util::min($offset, *$self->{BlockSize})) ) > 0)
1435 {
1436 $offset -= $got;
1437 last if $offset == 0 ;
1438 }
1439
1440 $here = $self->tell() ;
1441 return $offset == 0 ? 1 : 0 ;
1442}
1443
1444sub fileno
1445{
1446 my $self = shift ;
1447 return defined *$self->{FH}
1448 ? fileno *$self->{FH}
1449 : undef ;
1450}
1451
1452sub binmode
1453{
1454 1;
1455# my $self = shift ;
1456# return defined *$self->{FH}
1457# ? binmode *$self->{FH}
1458# : 1 ;
1459}
1460
1461sub opened
1462{
1463 my $self = shift ;
1464 return ! *$self->{Closed} ;
1465}
1466
1467sub autoflush
1468{
1469 my $self = shift ;
1470 return defined *$self->{FH}
1471 ? *$self->{FH}->autoflush(@_)
1472 : undef ;
1473}
1474
1475sub input_line_number
1476{
1477 my $self = shift ;
1478 my $last = *$self->{LineNo};
1479 $. = *$self->{LineNo} = $_[1] if @_ ;
1480 return $last;
1481}
1482
1483
148412µs*BINMODE = \&binmode;
14851800ns*SEEK = \&seek;
14861700ns*READ = \&read;
14871800ns*sysread = \&read;
14881800ns*TELL = \&tell;
14891700ns*EOF = \&eof;
1490
14911700ns*FILENO = \&fileno;
14921700ns*CLOSE = \&close;
1493
1494sub _notAvailable
1495
# spent 20µs within IO::Uncompress::Base::_notAvailable which was called 6 times, avg 3µs/call: # once (6µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1501 # once (3µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1502 # once (3µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1506 # once (3µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1505 # once (3µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1503 # once (3µs+0s) by IO::Uncompress::RawInflate::BEGIN@11 at line 1504
{
149664µs my $name = shift ;
1497630µs return sub { croak "$name Not Available: File opened only for intput" ; } ;
1498}
1499
1500
150114µs16µs*print = _notAvailable('print');
# spent 6µs making 1 call to IO::Uncompress::Base::_notAvailable
150212µs13µs*PRINT = _notAvailable('print');
# spent 3µs making 1 call to IO::Uncompress::Base::_notAvailable
150312µs13µs*printf = _notAvailable('printf');
# spent 3µs making 1 call to IO::Uncompress::Base::_notAvailable
150412µs13µs*PRINTF = _notAvailable('printf');
# spent 3µs making 1 call to IO::Uncompress::Base::_notAvailable
150512µs13µs*write = _notAvailable('write');
# spent 3µs making 1 call to IO::Uncompress::Base::_notAvailable
150612µs13µs*WRITE = _notAvailable('write');
# spent 3µs making 1 call to IO::Uncompress::Base::_notAvailable
1507
1508#*sysread = \&read;
1509#*syswrite = \&_notAvailable;
1510
- -
1513package IO::Uncompress::Base ;
1514
1515
1516115µs1 ;
1517__END__
Report produced by the NYTProf 6.04 Perl profiler, developed by Tim Bunce based on work by Adam Kaplan and Salvador Fandiño García.