Profile of IO/File.pm

Filename	/usr/local/perls/perl-5.26.1/lib/5.26.1/darwin-2level/IO/File.pm
Statements	Executed 52 statements in 572µs

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
4	1	1	348µs	348µs	IO::File::::CORE:openIO::File::CORE:open (opcode)
6	4	4	144µs	747µs	IO::File::::newIO::File::new
4	1	1	91µs	439µs	IO::File::::openIO::File::open
0	0	0	0s	0s	IO::File::::BEGINIO::File::BEGIN
0	0	0	0s	0s	IO::File::::binmodeIO::File::binmode

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 = IO::File->new();
14					if ($fh->open("< file")) {
15					print <$fh>;
16					$fh->close;
17					}
18
19					$fh = IO::File->new("> file");
20					if (defined $fh) {
21					print $fh "bar\n";
22					$fh->close;
23					}
24
25					$fh = IO::File->new("file", "r");
26					if (defined $fh) {
27					print <$fh>;
28					undef $fh; # automatically closes the file
29					}
30
31					$fh = IO::File->new("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<[email protected]>E<gt>.
124
125					=cut
126
127					use 5.006_001;
128					use strict;
129					our($VERSION, @EXPORT, @EXPORT_OK, @ISA);
130					use Carp;
131					use Symbol;
132					use SelectSaver;
133					use IO::Seekable;
134
135					require Exporter;
136
137					@ISA = qw(IO::Handle IO::Seekable Exporter);
138
139					$VERSION = "1.16";
140
141					@EXPORT = @IO::Seekable::EXPORT;
142
143					eval {
144					# Make all Fcntl O_XXX constants available for importing
145					require Fcntl;
146					my @O = grep /^O_/, @Fcntl::EXPORT;
147					Fcntl->import(@O); # first we import what we want to export
148					push(@EXPORT, @O);
149					};
150
151					################################################
152					## Constructor
153					##
154
155					# spent 747µs (144+603) within IO::File::new which was called 6 times, avg 125µs/call: # 3 times (63µs+233µs) by IO::Uncompress::Base::_create at line 432 of IO/Uncompress/Base.pm, avg 99µs/call # once (47µs+312µs) by CPAN::checklock at line 839 of CPAN.pm # once (27µs+42µs) by CPAN::FTP::_ftp_statistics at line 29 of CPAN/FTP.pm # once (7µs+16µs) by CPAN::Distribution::CHECKSUM_check_file at line 1492 of CPAN/Distribution.pm sub new {
156	6	6µs			my $type = shift;
157	6	7µs			my $class = ref($type) \|\| $type \|\| "IO::File";
158	6	20µs			@_ >= 0 && @_ <= 3
159					or croak "usage: $class->new([FILENAME [,MODE [,PERMS]]])";
160	6	43µs	6	164µs	my $fh = $class->SUPER::new(); # spent 164µs making 6 calls to IO::Handle::new, avg 27µs/call
161	6	28µs	4	439µs	if (@_) { # spent 439µs making 4 calls to IO::File::open, avg 110µs/call
162					$fh->open(@_)
163					or return undef;
164					}
165	6	30µs			$fh;
166					}
167
168					################################################
169					## Open
170					##
171
172					# spent 439µs (91+348) within IO::File::open which was called 4 times, avg 110µs/call: # 4 times (91µs+348µs) by IO::File::new at line 161, avg 110µs/call sub open {
173	4	9µs			@_ >= 2 && @_ <= 4 or croak 'usage: $fh->open(FILENAME [,MODE [,PERMS]])';
174	4	4µs			my ($fh, $file) = @_;
175	4	4µs			if (@_ > 2) {
176					my ($mode, $perms) = @_[2, 3];
177					if ($mode =~ /^\d+$/) {
178					defined $perms or $perms = 0666;
179					return sysopen($fh, $file, $mode, $perms);
180					} elsif ($mode =~ /:/) {
181					return open($fh, $mode, $file) if @_ == 3;
182					croak 'usage: $fh->open(FILENAME, IOLAYERS)';
183					} else {
184					return open($fh, IO::Handle::_open_mode_string($mode), $file);
185					}
186					}
187	4	421µs	4	348µs	open($fh, $file); # spent 348µs making 4 calls to IO::File::CORE:open, avg 87µs/call
188					}
189
190					################################################
191					## Binmode
192					##
193
194					sub binmode {
195					( @_ == 1 or @_ == 2 ) or croak 'usage $fh->binmode([LAYER])';
196
197					my($fh, $layer) = @_;
198
199					return binmode $$fh unless $layer;
200					return binmode $$fh, $layer;
201					}
202
203					1;

					# spent 348µs within IO::File::CORE:open which was called 4 times, avg 87µs/call: # 4 times (348µs+0s) by IO::File::open at line 187, avg 87µs/call sub IO::File::CORE:open; # opcode