Profile of IO/File.pm

Filename	/usr/lib64/perl5/vendor_perl/5.16.0/x86_64-linux/IO/File.pm
Statements	Executed 8452 statements in 152ms

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
2653	2	1	108ms	122ms	IO::File::::binmodeIO::File::binmode
2653	1	1	14.2ms	14.2ms	IO::File::::CORE:binmodeIO::File::CORE:binmode (opcode)
39	1	1	10.2ms	10.2ms	IO::File::::CORE:openIO::File::CORE:open (opcode)
1	1	1	3.77ms	4.14ms	IO::File::::BEGIN@131IO::File::BEGIN@131
39	1	1	3.75ms	19.2ms	IO::File::::openIO::File::open
1	1	1	2.58ms	30.5ms	IO::File::::BEGIN@133IO::File::BEGIN@133
39	1	1	2.25ms	6.15ms	IO::File::::newIO::File::new
1	1	1	1.58ms	2.21ms	IO::File::::BEGIN@132IO::File::BEGIN@132
146	2	1	822µs	822µs	IO::File::::CORE:matchIO::File::CORE:match (opcode)
1	1	1	101µs	101µs	IO::File::::BEGIN@127IO::File::BEGIN@127
1	1	1	57µs	353µs	IO::File::::BEGIN@130IO::File::BEGIN@130
1	1	1	50µs	144µs	IO::File::::BEGIN@128IO::File::BEGIN@128
1	1	1	40µs	40µs	IO::File::::BEGIN@134IO::File::BEGIN@134

Call graph for these subroutines as a Graphviz dot language file.

Line	State ments	Time on line	Calls	Time in subs	Code
1					#
2
3					package IO::File;
4
5					=head1 NAME
6
7					IO::File - supply object methods for filehandles
8
9					=head1 SYNOPSIS
10
11					use IO::File;
12
13					$fh = new IO::File;
14					if ($fh->open("< file")) {
15					print <$fh>;
16					$fh->close;
17					}
18
19					$fh = new IO::File "> file";
20					if (defined $fh) {
21					print $fh "bar\n";
22					$fh->close;
23					}
24
25					$fh = new IO::File "file", "r";
26					if (defined $fh) {
27					print <$fh>;
28					undef $fh; # automatically closes the file
29					}
30
31					$fh = new IO::File "file", O_WRONLY\|O_APPEND;
32					if (defined $fh) {
33					print $fh "corge\n";
34
35					$pos = $fh->getpos;
36					$fh->setpos($pos);
37
38					undef $fh; # automatically closes the file
39					}
40
41					autoflush STDOUT 1;
42
43					=head1 DESCRIPTION
44
45					C<IO::File> inherits from C<IO::Handle> and C<IO::Seekable>. It extends
46					these classes with methods that are specific to file handles.
47
48					=head1 CONSTRUCTOR
49
50					=over 4
51
52					=item new ( FILENAME [,MODE [,PERMS]] )
53
54					Creates an C<IO::File>. If it receives any parameters, they are passed to
55					the method C<open>; if the open fails, the object is destroyed. Otherwise,
56					it is returned to the caller.
57
58					=item new_tmpfile
59
60					Creates an C<IO::File> opened for read/write on a newly created temporary
61					file. On systems where this is possible, the temporary file is anonymous
62					(i.e. it is unlinked after creation, but held open). If the temporary
63					file cannot be created or opened, the C<IO::File> object is destroyed.
64					Otherwise, it is returned to the caller.
65
66					=back
67
68					=head1 METHODS
69
70					=over 4
71
72					=item open( FILENAME [,MODE [,PERMS]] )
73
74					=item open( FILENAME, IOLAYERS )
75
76					C<open> accepts one, two or three parameters. With one parameter,
77					it is just a front end for the built-in C<open> function. With two or three
78					parameters, the first parameter is a filename that may include
79					whitespace or other special characters, and the second parameter is
80					the open mode, optionally followed by a file permission value.
81
82					If C<IO::File::open> receives a Perl mode string ("E<gt>", "+E<lt>", etc.)
83					or an ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic
84					Perl C<open> operator (but protects any special characters).
85
86					If C<IO::File::open> is given a numeric mode, it passes that mode
87					and the optional permissions value to the Perl C<sysopen> operator.
88					The permissions default to 0666.
89
90					If C<IO::File::open> is given a mode that includes the C<:> character,
91					it passes all the three arguments to the three-argument C<open> operator.
92
93					For convenience, C<IO::File> exports the O_XXX constants from the
94					Fcntl module, if this module is available.
95
96					=item binmode( [LAYER] )
97
98					C<binmode> sets C<binmode> on the underlying C<IO> object, as documented
99					in C<perldoc -f binmode>.
100
101					C<binmode> accepts one optional parameter, which is the layer to be
102					passed on to the C<binmode> call.
103
104					=back
105
106					=head1 NOTE
107
108					Some operating systems may perform C<IO::File::new()> or C<IO::File::open()>
109					on a directory without errors. This behavior is not portable and not
110					suggested for use. Using C<opendir()> and C<readdir()> or C<IO::Dir> are
111					suggested instead.
112
113					=head1 SEE ALSO
114
115					L<perlfunc>,
116					L<perlop/"I/O Operators">,
117					L<IO::Handle>,
118					L<IO::Seekable>,
119					L<IO::Dir>
120
121					=head1 HISTORY
122
123					Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt>.
124
125					=cut
126
127	2	309µs	1	101µs	# spent 101µs within IO::File::BEGIN@127 which was called: # once (101µs+0s) by IO::AtomicFile::BEGIN@9 at line 127 use 5.006_001; # spent 101µs making 1 call to IO::File::BEGIN@127
128	2	291µs	2	238µs	# spent 144µs (50+94) within IO::File::BEGIN@128 which was called: # once (50µs+94µs) by IO::AtomicFile::BEGIN@9 at line 128 use strict; # spent 144µs making 1 call to IO::File::BEGIN@128 # spent 94µs making 1 call to strict::import
129	1	3µs			our($VERSION, @EXPORT, @EXPORT_OK, @ISA);
130	2	168µs	2	649µs	# spent 353µs (57+296) within IO::File::BEGIN@130 which was called: # once (57µs+296µs) by IO::AtomicFile::BEGIN@9 at line 130 use Carp; # spent 353µs making 1 call to IO::File::BEGIN@130 # spent 296µs making 1 call to Exporter::import
131	2	1.05ms	2	4.41ms	# spent 4.14ms (3.77+370µs) within IO::File::BEGIN@131 which was called: # once (3.77ms+370µs) by IO::AtomicFile::BEGIN@9 at line 131 use Symbol; # spent 4.14ms making 1 call to IO::File::BEGIN@131 # spent 269µs making 1 call to Exporter::import
132	2	965µs	1	2.21ms	# spent 2.21ms (1.58+628µs) within IO::File::BEGIN@132 which was called: # once (1.58ms+628µs) by IO::AtomicFile::BEGIN@9 at line 132 use SelectSaver; # spent 2.21ms making 1 call to IO::File::BEGIN@132
133	2	778µs	2	30.7ms	# spent 30.5ms (2.58+27.9) within IO::File::BEGIN@133 which was called: # once (2.58ms+27.9ms) by IO::AtomicFile::BEGIN@9 at line 133 use IO::Seekable; # spent 30.5ms making 1 call to IO::File::BEGIN@133 # spent 268µs making 1 call to Exporter::import
134	2	1.90ms	1	40µs	# spent 40µs within IO::File::BEGIN@134 which was called: # once (40µs+0s) by IO::AtomicFile::BEGIN@9 at line 134 use File::Spec; # spent 40µs making 1 call to IO::File::BEGIN@134
135
136	1	4µs			require Exporter;
137
138	1	64µs			@ISA = qw(IO::Handle IO::Seekable Exporter);
139
140	1	3µs			$VERSION = "1.14";
141
142	1	7µs			@EXPORT = @IO::Seekable::EXPORT;
143
144	1	6µs			eval {
145					# Make all Fcntl O_XXX constants available for importing
146	1	2µs			require Fcntl;
147	1	896µs	68	195µs	my @O = grep /^O_/, @Fcntl::EXPORT; # spent 195µs making 68 calls to IO::File::CORE:match, avg 3µs/call
148	1	29µs	1	1.12ms	Fcntl->import(@O); # first we import what we want to export # spent 1.12ms making 1 call to Exporter::import
149	1	40µs			push(@EXPORT, @O);
150					};
151
152					################################################
153					## Constructor
154					##
155
156					# spent 6.15ms (2.25+3.90) within IO::File::new which was called 39 times, avg 158µs/call: # 39 times (2.25ms+3.90ms) by IO::AtomicFile::new at line 34 of IO/AtomicFile.pm, avg 158µs/call sub new {
157	39	139µs			my $type = shift;
158	39	136µs			my $class = ref($type) \|\| $type \|\| "IO::File";
159	39	139µs			@_ >= 0 && @_ <= 3
160					or croak "usage: new $class [FILENAME [,MODE [,PERMS]]]";
161	39	1.24ms	39	3.90ms	my $fh = $class->SUPER::new(); # spent 3.90ms making 39 calls to IO::Handle::new, avg 100µs/call
162	39	68µs			if (@_) {
163					$fh->open(@_)
164					or return undef;
165					}
166	39	531µs			$fh;
167					}
168
169					################################################
170					## Open
171					##
172
173					# spent 19.2ms (3.75+15.5) within IO::File::open which was called 39 times, avg 493µs/call: # 39 times (3.75ms+15.5ms) by IO::AtomicFile::open at line 64 of IO/AtomicFile.pm, avg 493µs/call sub open {
174	39	164µs			@_ >= 2 && @_ <= 4 or croak 'usage: $fh->open(FILENAME [,MODE [,PERMS]])';
175	39	162µs			my ($fh, $file) = @_;
176	39	111µs			if (@_ > 2) {
177	39	172µs			my ($mode, $perms) = @_[2, 3];
178	39	1.67ms	78	627µs	if ($mode =~ /^\d+$/) { # spent 627µs making 78 calls to IO::File::CORE:match, avg 8µs/call
179					defined $perms or $perms = 0666;
180					return sysopen($fh, $file, $mode, $perms);
181					} elsif ($mode =~ /:/) {
182					return open($fh, $mode, $file) if @_ == 3;
183					croak 'usage: $fh->open(FILENAME, IOLAYERS)';
184					} else {
185	39	12.5ms	78	14.8ms	return open($fh, IO::Handle::_open_mode_string($mode), $file); # spent 10.2ms making 39 calls to IO::File::CORE:open, avg 263µs/call # spent 4.60ms making 39 calls to IO::Handle::_open_mode_string, avg 118µs/call
186					}
187					}
188					open($fh, $file);
189					}
190
191					################################################
192					## Binmode
193					##
194
195					# spent 122ms (108+14.2) within IO::File::binmode which was called 2653 times, avg 46µs/call: # 2614 times (107ms+13.9ms) by RTP::Webmerge::IO::readfile at line 146 of webmerge/scripts/modules/RTP/Webmerge/IO.pm, avg 46µs/call # 39 times (1.49ms+244µs) by RTP::Webmerge::IO::writefile at line 253 of webmerge/scripts/modules/RTP/Webmerge/IO.pm, avg 45µs/call sub binmode {
196	2653	7.07ms			( @_ == 1 or @_ == 2 ) or croak 'usage $fh->binmode([LAYER])';
197
198	2653	8.14ms			my($fh, $layer) = @_;
199
200	2653	113ms	2653	14.2ms	return binmode $$fh unless $layer; # spent 14.2ms making 2653 calls to IO::File::CORE:binmode, avg 5µs/call
201					return binmode $$fh, $layer;
202					}
203
204	1	46µs			1;

					# spent 14.2ms within IO::File::CORE:binmode which was called 2653 times, avg 5µs/call: # 2653 times (14.2ms+0s) by IO::File::binmode at line 200, avg 5µs/call sub IO::File::CORE:binmode; # opcode
					# spent 822µs within IO::File::CORE:match which was called 146 times, avg 6µs/call: # 78 times (627µs+0s) by IO::File::open at line 178, avg 8µs/call # 68 times (195µs+0s) by IO::AtomicFile::BEGIN@9 at line 147, avg 3µs/call sub IO::File::CORE:match; # opcode
					# spent 10.2ms within IO::File::CORE:open which was called 39 times, avg 263µs/call: # 39 times (10.2ms+0s) by IO::File::open at line 185, avg 263µs/call sub IO::File::CORE:open; # opcode