← Index
NYTProf Performance Profile   « block view • line view • sub view »
For bin/dpath
  Run on Tue Jun 5 15:31:33 2012
Reported on Tue Jun 5 15:31:39 2012

Filename/home/ss5/perl5/perlbrew/perls/perl-5.14.1/lib/5.14.1/x86_64-linux-thread-multi/IO/Handle.pm
StatementsExecuted 22 statements in 10.9ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1112.72ms3.01msIO::Handle::::BEGIN@264IO::Handle::BEGIN@264
1111.09ms2.35msIO::Handle::::BEGIN@266IO::Handle::BEGIN@266
1111.06ms1.49msIO::Handle::::BEGIN@265IO::Handle::BEGIN@265
11177µs77µsIO::Handle::::BEGIN@260IO::Handle::BEGIN@260
11149µs125µsIO::Handle::::BEGIN@624IO::Handle::BEGIN@624
11136µs295µsIO::Handle::::BEGIN@263IO::Handle::BEGIN@263
11132µs44µsIO::Handle::::BEGIN@261IO::Handle::BEGIN@261
0000s0sIO::Handle::::DESTROYIO::Handle::DESTROY
0000s0sIO::Handle::::_open_mode_stringIO::Handle::_open_mode_string
0000s0sIO::Handle::::autoflushIO::Handle::autoflush
0000s0sIO::Handle::::closeIO::Handle::close
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::::newIO::Handle::new
0000s0sIO::Handle::::new_from_fdIO::Handle::new_from_fd
0000s0sIO::Handle::::openedIO::Handle::opened
0000s0sIO::Handle::::output_field_separatorIO::Handle::output_field_separator
0000s0sIO::Handle::::output_record_separatorIO::Handle::output_record_separator
0000s0sIO::Handle::::printIO::Handle::print
0000s0sIO::Handle::::printfIO::Handle::printf
0000s0sIO::Handle::::printflushIO::Handle::printflush
0000s0sIO::Handle::::readIO::Handle::read
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
2602180µs177µs
# spent 77µs within IO::Handle::BEGIN@260 which was called: # once (77µs+0s) by SelfLoader::BEGIN@4 at line 260
use 5.006_001;
# spent 77µs making 1 call to IO::Handle::BEGIN@260
2612192µs257µs
# spent 44µs (32+13) within IO::Handle::BEGIN@261 which was called: # once (32µs+13µs) by SelfLoader::BEGIN@4 at line 261
use strict;
# spent 44µs making 1 call to IO::Handle::BEGIN@261 # spent 13µs making 1 call to strict::import
26213µsour($VERSION, @EXPORT_OK, @ISA);
2632108µs2554µs
# spent 295µs (36+259) within IO::Handle::BEGIN@263 which was called: # once (36µs+259µs) by SelfLoader::BEGIN@4 at line 263
use Carp;
# spent 295µs making 1 call to IO::Handle::BEGIN@263 # spent 259µs making 1 call to Exporter::import
2642647µs23.22ms
# spent 3.01ms (2.72+285µs) within IO::Handle::BEGIN@264 which was called: # once (2.72ms+285µs) by SelfLoader::BEGIN@4 at line 264
use Symbol;
# spent 3.01ms making 1 call to IO::Handle::BEGIN@264 # spent 213µs making 1 call to Exporter::import
2652584µs11.49ms
# spent 1.49ms (1.06+427µs) within IO::Handle::BEGIN@265 which was called: # once (1.06ms+427µs) by SelfLoader::BEGIN@4 at line 265
use SelectSaver;
# spent 1.49ms making 1 call to IO::Handle::BEGIN@265
26628.27ms12.35ms
# spent 2.35ms (1.09+1.26) within IO::Handle::BEGIN@266 which was called: # once (1.09ms+1.26ms) by SelfLoader::BEGIN@4 at line 266
use IO (); # Load the XS module
# spent 2.35ms making 1 call to IO::Handle::BEGIN@266
267
26812µsrequire Exporter;
269157µs@ISA = qw(Exporter);
270
27112µs$VERSION = "1.31";
272170µs$VERSION = eval $VERSION;
# spent 10µs executing statements in string eval
273
274118µ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
310sub new {
311 my $class = ref($_[0]) || $_[0] || "IO::Handle";
312 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 }
324 my $io = gensym;
325 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
351sub _open_mode_string {
352 my ($mode) = @_;
353 $mode =~ /^\+?(<|>>?)$/
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";
358 $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
380sub close {
381 @_ == 1 or croak 'usage: $io->close()';
382 my($io) = @_;
383
384 close($io);
385}
386
387################################################
388## Normal I/O functions.
389##
390
391# flock
392# select
393
394sub opened {
395 @_ == 1 or croak 'usage: $io->opened()';
396 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
414sub print {
415 @_ or croak 'usage: $io->print(ARGS)';
416 my $this = shift;
417 print $this @_;
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
439111µ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
454sub read {
455 @_ == 3 || @_ == 4 or croak 'usage: $io->read(BUF, LEN [, OFFSET])';
456 read($_[0], $_[1], $_[2], $_[3] || 0);
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 {
6242738µs2201µs
# spent 125µs (49+76) within IO::Handle::BEGIN@624 which was called: # once (49µs+76µs) by SelfLoader::BEGIN@4 at line 624
no strict 'refs';
# spent 125µs making 1 call to IO::Handle::BEGIN@624 # spent 76µ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
646132µs1;