← Index
NYTProf Performance Profile   « block view • line view • sub view »
For C:/lo/libo-master/solenv/bin/make_installer.pl
  Run on Mon Sep 24 00:52:54 2012
Reported on Mon Sep 24 07:34:47 2012

Filename/usr/lib/perl5/5.14/i686-cygwin-threads-64int/IO/Handle.pm
StatementsExecuted 499367 statements in 5.44s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
8811112.38s2.38sIO::Handle::::CORE:closeIO::Handle::CORE:close (opcode)
1034911889ms889msIO::Handle::::CORE:printIO::Handle::CORE:print (opcode)
6391811457ms457msIO::Handle::::CORE:readIO::Handle::CORE:read (opcode)
63918123366ms823msIO::Handle::::readIO::Handle::read
1879311334ms477msIO::Handle::::_open_mode_stringIO::Handle::_open_mode_string
9123922279ms279msIO::Handle::::openedIO::Handle::opened
1879311164ms343msIO::Handle::::newIO::Handle::new
103491182.5ms971msIO::Handle::::printIO::Handle::print
88112277.2ms2.45sIO::Handle::::closeIO::Handle::close
273941168.6ms68.6msIO::Handle::::CORE:substIO::Handle::CORE:subst (opcode)
375861147.4ms47.4msIO::Handle::::CORE:substcontIO::Handle::CORE:substcont (opcode)
187931127.6ms27.6msIO::Handle::::CORE:matchIO::Handle::CORE:match (opcode)
86011116.3ms16.3msIO::Handle::::clearerrIO::Handle::clearerr (xsub)
1112.77ms4.32msIO::Handle::::BEGIN@266IO::Handle::BEGIN@266
111264µs264µsIO::Handle::::BEGIN@260IO::Handle::BEGIN@260
111101µs200µsIO::Handle::::BEGIN@263IO::Handle::BEGIN@263
11119µs29µsIO::Handle::::BEGIN@261IO::Handle::BEGIN@261
11117µs20µsIO::Handle::::BEGIN@265IO::Handle::BEGIN@265
11116µs45µsIO::Handle::::BEGIN@624IO::Handle::BEGIN@624
11116µs83µsIO::Handle::::BEGIN@264IO::Handle::BEGIN@264
0000s0sIO::Handle::::DESTROYIO::Handle::DESTROY
0000s0sIO::Handle::::autoflushIO::Handle::autoflush
0000s0sIO::Handle::::constantIO::Handle::constant
0000s0sIO::Handle::::eofIO::Handle::eof
0000s0sIO::Handle::::fcntlIO::Handle::fcntl
0000s0sIO::Handle::::fdopenIO::Handle::fdopen
0000s0sIO::Handle::::filenoIO::Handle::fileno
0000s0sIO::Handle::::format_formfeedIO::Handle::format_formfeed
0000s0sIO::Handle::::format_line_break_charactersIO::Handle::format_line_break_characters
0000s0sIO::Handle::::format_lines_leftIO::Handle::format_lines_left
0000s0sIO::Handle::::format_lines_per_pageIO::Handle::format_lines_per_page
0000s0sIO::Handle::::format_nameIO::Handle::format_name
0000s0sIO::Handle::::format_page_numberIO::Handle::format_page_number
0000s0sIO::Handle::::format_top_nameIO::Handle::format_top_name
0000s0sIO::Handle::::format_writeIO::Handle::format_write
0000s0sIO::Handle::::formlineIO::Handle::formline
0000s0sIO::Handle::::getcIO::Handle::getc
0000s0sIO::Handle::::getlineIO::Handle::getline
0000s0sIO::Handle::::getlinesIO::Handle::getlines
0000s0sIO::Handle::::input_line_numberIO::Handle::input_line_number
0000s0sIO::Handle::::input_record_separatorIO::Handle::input_record_separator
0000s0sIO::Handle::::ioctlIO::Handle::ioctl
0000s0sIO::Handle::::new_from_fdIO::Handle::new_from_fd
0000s0sIO::Handle::::output_field_separatorIO::Handle::output_field_separator
0000s0sIO::Handle::::output_record_separatorIO::Handle::output_record_separator
0000s0sIO::Handle::::printfIO::Handle::printf
0000s0sIO::Handle::::printflushIO::Handle::printflush
0000s0sIO::Handle::::sayIO::Handle::say
0000s0sIO::Handle::::statIO::Handle::stat
0000s0sIO::Handle::::sysreadIO::Handle::sysread
0000s0sIO::Handle::::syswriteIO::Handle::syswrite
0000s0sIO::Handle::::truncateIO::Handle::truncate
0000s0sIO::Handle::::writeIO::Handle::write
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1package IO::Handle;
2
3=head1 NAME
4
5IO::Handle - supply object methods for I/O handles
6
7=head1 SYNOPSIS
8
9 use IO::Handle;
10
11 $io = IO::Handle->new();
12 if ($io->fdopen(fileno(STDIN),"r")) {
13 print $io->getline;
14 $io->close;
15 }
16
17 $io = IO::Handle->new();
18 if ($io->fdopen(fileno(STDOUT),"w")) {
19 $io->print("Some text\n");
20 }
21
22 # setvbuf is not available by default on Perls 5.8.0 and later.
23 use IO::Handle '_IOLBF';
24 $io->setvbuf($buffer_var, _IOLBF, 1024);
25
26 undef $io; # automatically closes the file if it's open
27
28 autoflush STDOUT 1;
29
30=head1 DESCRIPTION
31
32C<IO::Handle> is the base class for all other IO handle classes. It is
33not intended that objects of C<IO::Handle> would be created directly,
34but instead C<IO::Handle> is inherited from by several other classes
35in the IO hierarchy.
36
37If you are reading this documentation, looking for a replacement for
38the C<FileHandle> package, then I suggest you read the documentation
39for C<IO::File> too.
40
41=head1 CONSTRUCTOR
42
43=over 4
44
45=item new ()
46
47Creates a new C<IO::Handle> object.
48
49=item new_from_fd ( FD, MODE )
50
51Creates an C<IO::Handle> like C<new> does.
52It requires two parameters, which are passed to the method C<fdopen>;
53if the fdopen fails, the object is destroyed. Otherwise, it is returned
54to the caller.
55
56=back
57
58=head1 METHODS
59
60See L<perlfunc> for complete descriptions of each of the following
61supported C<IO::Handle> methods, which are just front ends for the
62corresponding built-in functions:
63
64 $io->close
65 $io->eof
66 $io->fcntl( FUNCTION, SCALAR )
67 $io->fileno
68 $io->format_write( [FORMAT_NAME] )
69 $io->getc
70 $io->ioctl( FUNCTION, SCALAR )
71 $io->read ( BUF, LEN, [OFFSET] )
72 $io->print ( ARGS )
73 $io->printf ( FMT, [ARGS] )
74 $io->say ( ARGS )
75 $io->stat
76 $io->sysread ( BUF, LEN, [OFFSET] )
77 $io->syswrite ( BUF, [LEN, [OFFSET]] )
78 $io->truncate ( LEN )
79
80See L<perlvar> for complete descriptions of each of the following
81supported C<IO::Handle> methods. All of them return the previous
82value of the attribute and takes an optional single argument that when
83given will set the value. If no argument is given the previous value
84is unchanged (except for $io->autoflush will actually turn ON
85autoflush by default).
86
87 $io->autoflush ( [BOOL] ) $|
88 $io->format_page_number( [NUM] ) $%
89 $io->format_lines_per_page( [NUM] ) $=
90 $io->format_lines_left( [NUM] ) $-
91 $io->format_name( [STR] ) $~
92 $io->format_top_name( [STR] ) $^
93 $io->input_line_number( [NUM]) $.
94
95The following methods are not supported on a per-filehandle basis.
96
97 IO::Handle->format_line_break_characters( [STR] ) $:
98 IO::Handle->format_formfeed( [STR]) $^L
99 IO::Handle->output_field_separator( [STR] ) $,
100 IO::Handle->output_record_separator( [STR] ) $\
101
102 IO::Handle->input_record_separator( [STR] ) $/
103
104Furthermore, for doing normal I/O you might need these:
105
106=over 4
107
108=item $io->fdopen ( FD, MODE )
109
110C<fdopen> is like an ordinary C<open> except that its first parameter
111is not a filename but rather a file handle name, an IO::Handle object,
112or a file descriptor number. (For the documentation of the C<open>
113method, see L<IO::File>.)
114
115=item $io->opened
116
117Returns true if the object is currently a valid file descriptor, false
118otherwise.
119
120=item $io->getline
121
122This works like <$io> described in L<perlop/"I/O Operators">
123except that it's more readable and can be safely called in a
124list context but still returns just one line. If used as the conditional
125+within a C<while> or C-style C<for> loop, however, you will need to
126+emulate the functionality of <$io> with C<< defined($_ = $io->getline) >>.
127
128=item $io->getlines
129
130This works like <$io> when called in a list context to read all
131the remaining lines in a file, except that it's more readable.
132It will also croak() if accidentally called in a scalar context.
133
134=item $io->ungetc ( ORD )
135
136Pushes a character with the given ordinal value back onto the given
137handle's input stream. Only one character of pushback per handle is
138guaranteed.
139
140=item $io->write ( BUF, LEN [, OFFSET ] )
141
142This C<write> is like C<write> found in C, that is it is the
143opposite of read. The wrapper for the perl C<write> function is
144called C<format_write>.
145
146=item $io->error
147
148Returns a true value if the given handle has experienced any errors
149since it was opened or since the last call to C<clearerr>, or if the
150handle is invalid. It only returns false for a valid handle with no
151outstanding errors.
152
153=item $io->clearerr
154
155Clear the given handle's error indicator. Returns -1 if the handle is
156invalid, 0 otherwise.
157
158=item $io->sync
159
160C<sync> synchronizes a file's in-memory state with that on the
161physical medium. C<sync> does not operate at the perlio api level, but
162operates on the file descriptor (similar to sysread, sysseek and
163systell). This means that any data held at the perlio api level will not
164be synchronized. To synchronize data that is buffered at the perlio api
165level you must use the flush method. C<sync> is not implemented on all
166platforms. Returns "0 but true" on success, C<undef> on error, C<undef>
167for an invalid handle. See L<fsync(3c)>.
168
169=item $io->flush
170
171C<flush> causes perl to flush any buffered data at the perlio api level.
172Any unread data in the buffer will be discarded, and any unwritten data
173will be written to the underlying file descriptor. Returns "0 but true"
174on success, C<undef> on error.
175
176=item $io->printflush ( ARGS )
177
178Turns on autoflush, print ARGS and then restores the autoflush status of the
179C<IO::Handle> object. Returns the return value from print.
180
181=item $io->blocking ( [ BOOL ] )
182
183If called with an argument C<blocking> will turn on non-blocking IO if
184C<BOOL> is false, and turn it off if C<BOOL> is true.
185
186C<blocking> will return the value of the previous setting, or the
187current setting if C<BOOL> is not given.
188
189If an error occurs C<blocking> will return undef and C<$!> will be set.
190
191=back
192
193
194If the C functions setbuf() and/or setvbuf() are available, then
195C<IO::Handle::setbuf> and C<IO::Handle::setvbuf> set the buffering
196policy for an IO::Handle. The calling sequences for the Perl functions
197are the same as their C counterparts--including the constants C<_IOFBF>,
198C<_IOLBF>, and C<_IONBF> for setvbuf()--except that the buffer parameter
199specifies a scalar variable to use as a buffer. You should only
200change the buffer before any I/O, or immediately after calling flush.
201
202WARNING: The IO::Handle::setvbuf() is not available by default on
203Perls 5.8.0 and later because setvbuf() is rather specific to using
204the stdio library, while Perl prefers the new perlio subsystem instead.
205
206WARNING: A variable used as a buffer by C<setbuf> or C<setvbuf> B<must not
207be modified> in any way until the IO::Handle is closed or C<setbuf> or
208C<setvbuf> is called again, or memory corruption may result! Remember that
209the order of global destruction is undefined, so even if your buffer
210variable remains in scope until program termination, it may be undefined
211before the file IO::Handle is closed. Note that you need to import the
212constants C<_IOFBF>, C<_IOLBF>, and C<_IONBF> explicitly. Like C, setbuf
213returns nothing. setvbuf returns "0 but true", on success, C<undef> on
214failure.
215
216Lastly, there is a special method for working under B<-T> and setuid/gid
217scripts:
218
219=over 4
220
221=item $io->untaint
222
223Marks the object as taint-clean, and as such data read from it will also
224be considered taint-clean. Note that this is a very trusting action to
225take, and appropriate consideration for the data source and potential
226vulnerability should be kept in mind. Returns 0 on success, -1 if setting
227the taint-clean flag failed. (eg invalid handle)
228
229=back
230
231=head1 NOTE
232
233An C<IO::Handle> object is a reference to a symbol/GLOB reference (see
234the C<Symbol> package). Some modules that
235inherit from C<IO::Handle> may want to keep object related variables
236in the hash table part of the GLOB. In an attempt to prevent modules
237trampling on each other I propose the that any such module should prefix
238its variables with its own name separated by _'s. For example the IO::Socket
239module keeps a C<timeout> variable in 'io_socket_timeout'.
240
241=head1 SEE ALSO
242
243L<perlfunc>,
244L<perlop/"I/O Operators">,
245L<IO::File>
246
247=head1 BUGS
248
249Due to backwards compatibility, all filehandles resemble objects
250of class C<IO::Handle>, or actually classes derived from that class.
251They actually aren't. Which means you can't derive your own
252class from C<IO::Handle> and inherit those methods.
253
254=head1 HISTORY
255
256Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt>
257
258=cut
259
2602192µs1264µs
# spent 264µs within IO::Handle::BEGIN@260 which was called: # once (264µs+0s) by IO::Seekable::BEGIN@101 at line 260
use 5.006_001;
# spent 264µs making 1 call to IO::Handle::BEGIN@260
2612178µs239µs
# spent 29µs (19+10) within IO::Handle::BEGIN@261 which was called: # once (19µs+10µs) by IO::Seekable::BEGIN@101 at line 261
use strict;
# spent 29µs making 1 call to IO::Handle::BEGIN@261 # spent 10µs making 1 call to strict::import
26211µsour($VERSION, @EXPORT_OK, @ISA);
263258µs2298µs
# spent 200µs (101+99) within IO::Handle::BEGIN@263 which was called: # once (101µs+99µs) by IO::Seekable::BEGIN@101 at line 263
use Carp;
# spent 200µs making 1 call to IO::Handle::BEGIN@263 # spent 99µs making 1 call to Exporter::import
264255µs2149µs
# spent 83µs (16+66) within IO::Handle::BEGIN@264 which was called: # once (16µs+66µs) by IO::Seekable::BEGIN@101 at line 264
use Symbol;
# spent 83µs making 1 call to IO::Handle::BEGIN@264 # spent 66µs making 1 call to Exporter::import
265251µs224µs
# spent 20µs (17+4) within IO::Handle::BEGIN@265 which was called: # once (17µs+4µs) by IO::Seekable::BEGIN@101 at line 265
use SelectSaver;
# spent 20µs making 1 call to IO::Handle::BEGIN@265 # spent 4µs making 1 call to UNIVERSAL::import
26626.15ms14.32ms
# spent 4.32ms (2.77+1.55) within IO::Handle::BEGIN@266 which was called: # once (2.77ms+1.55ms) by IO::Seekable::BEGIN@101 at line 266
use IO (); # Load the XS module
# spent 4.32ms making 1 call to IO::Handle::BEGIN@266
267
26811µsrequire Exporter;
269123µs@ISA = qw(Exporter);
270
27111µs$VERSION = "1.31";
272127µs$VERSION = eval $VERSION;
# spent 6µs executing statements in string eval
273
274113µs@EXPORT_OK = qw(
275 autoflush
276 output_field_separator
277 output_record_separator
278 input_record_separator
279 input_line_number
280 format_page_number
281 format_lines_per_page
282 format_lines_left
283 format_name
284 format_top_name
285 format_line_break_characters
286 format_formfeed
287 format_write
288
289 print
290 printf
291 say
292 getline
293 getlines
294
295 printflush
296 flush
297
298 SEEK_SET
299 SEEK_CUR
300 SEEK_END
301 _IOFBF
302 _IOLBF
303 _IONBF
304);
305
306################################################
307## Constructors, destructors.
308##
309
310
# spent 343ms (164+179) within IO::Handle::new which was called 18793 times, avg 18µs/call: # 18793 times (164ms+179ms) by IO::File::new at line 161 of IO/File.pm, avg 18µs/call
sub new {
3111879315.6ms my $class = ref($_[0]) || $_[0] || "IO::Handle";
3121879311.6ms if (@_ != 1) {
313 # Since perl will automatically require IO::File if needed, but
314 # also initialises IO::File's @ISA as part of the core we must
315 # ensure IO::File is loaded if IO::Handle is. This avoids effect-
316 # ively "half-loading" IO::File.
317 if ($] > 5.013 && $class eq 'IO::File' && !$INC{"IO/File.pm"}) {
318 require IO::File;
319 shift;
320 return IO::File::->new(@_);
321 }
322 croak "usage: $class->new()";
323 }
3241879347.7ms18793179ms my $io = gensym;
# spent 179ms making 18793 calls to Symbol::gensym, avg 10µs/call
3251879376.1ms bless $io, $class;
326}
327
328sub new_from_fd {
329 my $class = ref($_[0]) || $_[0] || "IO::Handle";
330 @_ == 3 or croak "usage: $class->new_from_fd(FD, MODE)";
331 my $io = gensym;
332 shift;
333 IO::Handle::fdopen($io, @_)
334 or return undef;
335 bless $io, $class;
336}
337
338#
339# There is no need for DESTROY to do anything, because when the
340# last reference to an IO object is gone, Perl automatically
341# closes its associated files (if any). However, to avoid any
342# attempts to autoload DESTROY, we here define it to do nothing.
343#
344sub DESTROY {}
345
346
347################################################
348## Open and close.
349##
350
351
# spent 477ms (334+143) within IO::Handle::_open_mode_string which was called 18793 times, avg 25µs/call: # 18793 times (334ms+143ms) by IO::File::open at line 185 of IO/File.pm, avg 25µs/call
sub _open_mode_string {
3521879316.4ms my ($mode) = @_;
35318793396ms83773143ms $mode =~ /^\+?(<|>>?)$/
# spent 68.6ms making 27394 calls to IO::Handle::CORE:subst, avg 3µs/call # spent 47.4ms making 37586 calls to IO::Handle::CORE:substcont, avg 1µs/call # spent 27.6ms making 18793 calls to IO::Handle::CORE:match, avg 1µs/call
354 or $mode =~ s/^r(\+?)$/$1</
355 or $mode =~ s/^w(\+?)$/$1>/
356 or $mode =~ s/^a(\+?)$/$1>>/
357 or croak "IO::Handle: bad open mode: $mode";
3581879384.4ms $mode;
359}
360
361sub fdopen {
362 @_ == 3 or croak 'usage: $io->fdopen(FD, MODE)';
363 my ($io, $fd, $mode) = @_;
364 local(*GLOB);
365
366 if (ref($fd) && "".$fd =~ /GLOB\(/o) {
367 # It's a glob reference; Alias it as we cannot get name of anon GLOBs
368 my $n = qualify(*GLOB);
369 *GLOB = *{*$fd};
370 $fd = $n;
371 } elsif ($fd =~ m#^\d+$#) {
372 # It's an FD number; prefix with "=".
373 $fd = "=$fd";
374 }
375
376 open($io, _open_mode_string($mode) . '&' . $fd)
377 ? $io : undef;
378}
379
380
# spent 2.45s (77.2ms+2.38) within IO::Handle::close which was called 8811 times, avg 279µs/call: # 8601 times (75.4ms+2.37s) by Archive::Zip::Member::extractToFileNamed at line 489 of Archive/Zip/Member.pm, avg 284µs/call # 210 times (1.76ms+7.32ms) by Archive::Zip::Archive::read at line 551 of Archive/Zip/Archive.pm, avg 43µs/call
sub close {
38188116.38ms @_ == 1 or croak 'usage: $io->close()';
38288117.13ms my($io) = @_;
383
38488112.46s88112.38s close($io);
# spent 2.38s making 8811 calls to IO::Handle::CORE:close, avg 270µs/call
385}
386
387################################################
388## Normal I/O functions.
389##
390
391# flock
392# select
393
394
# spent 279ms within IO::Handle::opened which was called 91239 times, avg 3µs/call: # 91029 times (278ms+0s) by Archive::Zip::FileMember::fh at line 30 of Archive/Zip/FileMember.pm, avg 3µs/call # 210 times (940µs+0s) by Archive::Zip::Archive::readFromFileHandle at line 570 of Archive/Zip/Archive.pm, avg 4µs/call
sub opened {
3959123951.1ms @_ == 1 or croak 'usage: $io->opened()';
39691239366ms defined fileno($_[0]);
397}
398
399sub fileno {
400 @_ == 1 or croak 'usage: $io->fileno()';
401 fileno($_[0]);
402}
403
404sub getc {
405 @_ == 1 or croak 'usage: $io->getc()';
406 getc($_[0]);
407}
408
409sub eof {
410 @_ == 1 or croak 'usage: $io->eof()';
411 eof($_[0]);
412}
413
414
# spent 971ms (82.5+889) within IO::Handle::print which was called 10349 times, avg 94µs/call: # 10349 times (82.5ms+889ms) by Archive::Zip::_print at line 414 of Archive/Zip.pm, avg 94µs/call
sub print {
415103495.71ms @_ or croak 'usage: $io->print(ARGS)';
416103495.36ms my $this = shift;
41710349973ms10349889ms print $this @_;
# spent 889ms making 10349 calls to IO::Handle::CORE:print, avg 86µs/call
418}
419
420sub printf {
421 @_ >= 2 or croak 'usage: $io->printf(FMT,[ARGS])';
422 my $this = shift;
423 printf $this @_;
424}
425
426sub say {
427 @_ or croak 'usage: $io->say(ARGS)';
428 my $this = shift;
429 local $\ = "\n";
430 print $this @_;
431}
432
433sub getline {
434 @_ == 1 or croak 'usage: $io->getline()';
435 my $this = shift;
436 return scalar <$this>;
437}
438
43914µs*gets = \&getline; # deprecated
440
441sub getlines {
442 @_ == 1 or croak 'usage: $io->getlines()';
443 wantarray or
444 croak 'Can\'t call $io->getlines in a scalar context, use $io->getline';
445 my $this = shift;
446 return <$this>;
447}
448
449sub truncate {
450 @_ == 2 or croak 'usage: $io->truncate(LEN)';
451 truncate($_[0], $_[1]);
452}
453
454
# spent 823ms (366+457) within IO::Handle::read which was called 63918 times, avg 13µs/call: # 20174 times (123ms+198ms) by Archive::Zip::_readSignature at line 455 of Archive/Zip.pm, avg 16µs/call # 10349 times (65.2ms+210ms) by Archive::Zip::ZipFileMember::_readRawChunk at line 411 of Archive/Zip/ZipFileMember.pm, avg 27µs/call # 9982 times (53.0ms+12.5ms) by Archive::Zip::ZipFileMember::_readCentralDirectoryFileHeader at line 348 of Archive/Zip/ZipFileMember.pm, avg 7µs/call # 9982 times (52.2ms+9.47ms) by Archive::Zip::ZipFileMember::_readCentralDirectoryFileHeader at line 321 of Archive/Zip/ZipFileMember.pm, avg 6µs/call # 8601 times (45.6ms+8.91ms) by Archive::Zip::ZipFileMember::_skipLocalFileHeader at line 137 of Archive/Zip/ZipFileMember.pm, avg 6µs/call # 1381 times (7.30ms+1.39ms) by Archive::Zip::ZipFileMember::_readLocalFileHeader at line 206 of Archive/Zip/ZipFileMember.pm, avg 6µs/call # 1381 times (7.29ms+1.22ms) by Archive::Zip::ZipFileMember::_readLocalFileHeader at line 225 of Archive/Zip/ZipFileMember.pm, avg 6µs/call # 824 times (4.08ms+946µs) by Archive::Zip::ZipFileMember::_readCentralDirectoryFileHeader at line 354 of Archive/Zip/ZipFileMember.pm, avg 6µs/call # 822 times (5.05ms+9.38ms) by Archive::Zip::ZipFileMember::_skipLocalFileHeader at line 162 of Archive/Zip/ZipFileMember.pm, avg 18µs/call # 210 times (1.53ms+3.83ms) by Archive::Zip::Archive::_findEndOfCentralDirectory at line 678 of Archive/Zip/Archive.pm, avg 26µs/call # 210 times (1.29ms+1.76ms) by Archive::Zip::Archive::_readEndOfCentralDirectory at line 628 of Archive/Zip/Archive.pm, avg 15µs/call # 2 times (11µs+3µs) by Archive::Zip::ZipFileMember::_readLocalFileHeader at line 233 of Archive/Zip/ZipFileMember.pm, avg 7µs/call
sub read {
4556391837.5ms @_ == 3 || @_ == 4 or croak 'usage: $io->read(BUF, LEN [, OFFSET])';
45663918879ms63918457ms read($_[0], $_[1], $_[2], $_[3] || 0);
# spent 457ms making 63918 calls to IO::Handle::CORE:read, avg 7µs/call
457}
458
459sub sysread {
460 @_ == 3 || @_ == 4 or croak 'usage: $io->sysread(BUF, LEN [, OFFSET])';
461 sysread($_[0], $_[1], $_[2], $_[3] || 0);
462}
463
464sub write {
465 @_ >= 2 && @_ <= 4 or croak 'usage: $io->write(BUF [, LEN [, OFFSET]])';
466 local($\) = "";
467 $_[2] = length($_[1]) unless defined $_[2];
468 print { $_[0] } substr($_[1], $_[3] || 0, $_[2]);
469}
470
471sub syswrite {
472 @_ >= 2 && @_ <= 4 or croak 'usage: $io->syswrite(BUF [, LEN [, OFFSET]])';
473 if (defined($_[2])) {
474 syswrite($_[0], $_[1], $_[2], $_[3] || 0);
475 } else {
476 syswrite($_[0], $_[1]);
477 }
478}
479
480sub stat {
481 @_ == 1 or croak 'usage: $io->stat()';
482 stat($_[0]);
483}
484
485################################################
486## State modification functions.
487##
488
489sub autoflush {
490 my $old = new SelectSaver qualify($_[0], caller);
491 my $prev = $|;
492 $| = @_ > 1 ? $_[1] : 1;
493 $prev;
494}
495
496sub output_field_separator {
497 carp "output_field_separator is not supported on a per-handle basis"
498 if ref($_[0]);
499 my $prev = $,;
500 $, = $_[1] if @_ > 1;
501 $prev;
502}
503
504sub output_record_separator {
505 carp "output_record_separator is not supported on a per-handle basis"
506 if ref($_[0]);
507 my $prev = $\;
508 $\ = $_[1] if @_ > 1;
509 $prev;
510}
511
512sub input_record_separator {
513 carp "input_record_separator is not supported on a per-handle basis"
514 if ref($_[0]);
515 my $prev = $/;
516 $/ = $_[1] if @_ > 1;
517 $prev;
518}
519
520sub input_line_number {
521 local $.;
522 () = tell qualify($_[0], caller) if ref($_[0]);
523 my $prev = $.;
524 $. = $_[1] if @_ > 1;
525 $prev;
526}
527
528sub format_page_number {
529 my $old;
530 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
531 my $prev = $%;
532 $% = $_[1] if @_ > 1;
533 $prev;
534}
535
536sub format_lines_per_page {
537 my $old;
538 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
539 my $prev = $=;
540 $= = $_[1] if @_ > 1;
541 $prev;
542}
543
544sub format_lines_left {
545 my $old;
546 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
547 my $prev = $-;
548 $- = $_[1] if @_ > 1;
549 $prev;
550}
551
552sub format_name {
553 my $old;
554 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
555 my $prev = $~;
556 $~ = qualify($_[1], caller) if @_ > 1;
557 $prev;
558}
559
560sub format_top_name {
561 my $old;
562 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
563 my $prev = $^;
564 $^ = qualify($_[1], caller) if @_ > 1;
565 $prev;
566}
567
568sub format_line_break_characters {
569 carp "format_line_break_characters is not supported on a per-handle basis"
570 if ref($_[0]);
571 my $prev = $:;
572 $: = $_[1] if @_ > 1;
573 $prev;
574}
575
576sub format_formfeed {
577 carp "format_formfeed is not supported on a per-handle basis"
578 if ref($_[0]);
579 my $prev = $^L;
580 $^L = $_[1] if @_ > 1;
581 $prev;
582}
583
584sub formline {
585 my $io = shift;
586 my $picture = shift;
587 local($^A) = $^A;
588 local($\) = "";
589 formline($picture, @_);
590 print $io $^A;
591}
592
593sub format_write {
594 @_ < 3 || croak 'usage: $io->write( [FORMAT_NAME] )';
595 if (@_ == 2) {
596 my ($io, $fmt) = @_;
597 my $oldfmt = $io->format_name(qualify($fmt,caller));
598 CORE::write($io);
599 $io->format_name($oldfmt);
600 } else {
601 CORE::write($_[0]);
602 }
603}
604
605sub fcntl {
606 @_ == 3 || croak 'usage: $io->fcntl( OP, VALUE );';
607 my ($io, $op) = @_;
608 return fcntl($io, $op, $_[2]);
609}
610
611sub ioctl {
612 @_ == 3 || croak 'usage: $io->ioctl( OP, VALUE );';
613 my ($io, $op) = @_;
614 return ioctl($io, $op, $_[2]);
615}
616
617# this sub is for compatibility with older releases of IO that used
618# a sub called constant to determine if a constant existed -- GMB
619#
620# The SEEK_* and _IO?BF constants were the only constants at that time
621# any new code should just chech defined(&CONSTANT_NAME)
622
623sub constant {
6242338µs274µs
# spent 45µs (16+29) within IO::Handle::BEGIN@624 which was called: # once (16µs+29µs) by IO::Seekable::BEGIN@101 at line 624
no strict 'refs';
# spent 45µs making 1 call to IO::Handle::BEGIN@624 # spent 29µs making 1 call to strict::unimport
625 my $name = shift;
626 (($name =~ /^(SEEK_(SET|CUR|END)|_IO[FLN]BF)$/) && defined &{$name})
627 ? &{$name}() : undef;
628}
629
630
631# so that flush.pl can be deprecated
632
633sub printflush {
634 my $io = shift;
635 my $old;
636 $old = new SelectSaver qualify($io, caller) if ref($io);
637 local $| = 1;
638 if(ref($io)) {
639 print $io @_;
640 }
641 else {
642 print @_;
643 }
644}
645
646142µs1;
 
# spent 2.38s within IO::Handle::CORE:close which was called 8811 times, avg 270µs/call: # 8811 times (2.38s+0s) by IO::Handle::close at line 384, avg 270µs/call
sub IO::Handle::CORE:close; # opcode
# spent 27.6ms within IO::Handle::CORE:match which was called 18793 times, avg 1µs/call: # 18793 times (27.6ms+0s) by IO::Handle::_open_mode_string at line 353, avg 1µs/call
sub IO::Handle::CORE:match; # opcode
# spent 889ms within IO::Handle::CORE:print which was called 10349 times, avg 86µs/call: # 10349 times (889ms+0s) by IO::Handle::print at line 417, avg 86µs/call
sub IO::Handle::CORE:print; # opcode
# spent 457ms within IO::Handle::CORE:read which was called 63918 times, avg 7µs/call: # 63918 times (457ms+0s) by IO::Handle::read at line 456, avg 7µs/call
sub IO::Handle::CORE:read; # opcode
# spent 68.6ms within IO::Handle::CORE:subst which was called 27394 times, avg 3µs/call: # 27394 times (68.6ms+0s) by IO::Handle::_open_mode_string at line 353, avg 3µs/call
sub IO::Handle::CORE:subst; # opcode
# spent 47.4ms within IO::Handle::CORE:substcont which was called 37586 times, avg 1µs/call: # 37586 times (47.4ms+0s) by IO::Handle::_open_mode_string at line 353, avg 1µs/call
sub IO::Handle::CORE:substcont; # opcode
# spent 16.3ms within IO::Handle::clearerr which was called 8601 times, avg 2µs/call: # 8601 times (16.3ms+0s) by Archive::Zip::ZipFileMember::rewindData at line 386 of Archive/Zip/ZipFileMember.pm, avg 2µs/call
sub IO::Handle::clearerr; # xsub
Report produced by the NYTProf 4.09 Perl profiler, developed by Tim Bunce and Adam Kaplan.