← Index
NYTProf Performance Profile   « line view »
For /Users/brian/bin/perls/cpan5.26.1
  Run on Sat Dec 30 01:41:10 2017
Reported on Sat Dec 30 01:44:14 2017

Filename/usr/local/perls/perl-5.26.1/lib/5.26.1/Term/ReadLine.pm
StatementsExecuted 167 statements in 20.4s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
41120.4s20.4sTerm::ReadLine::Tk::::CORE:readline Term::ReadLine::Tk::CORE:readline (opcode)
3115.06ms49.0msTerm::ReadLine::TermCap::::LoadTermCapTerm::ReadLine::TermCap::LoadTermCap
411277µs20.4sTerm::ReadLine::Tk::::get_line Term::ReadLine::Tk::get_line
411223µs20.4sTerm::ReadLine::Stub::::readline Term::ReadLine::Stub::readline
821215µs279µsTerm::ReadLine::Stub::::CORE:print Term::ReadLine::Stub::CORE:print (opcode)
332179µs49.3msTerm::ReadLine::TermCap::::ornamentsTerm::ReadLine::TermCap::ornaments
33186µs86µsTerm::ReadLine::Stub::::CORE:open Term::ReadLine::Stub::CORE:open (opcode)
11175µs49.3msTerm::ReadLine::Stub::::new Term::ReadLine::Stub::new
11159µs77µsCPAN::::BEGIN@201 CPAN::BEGIN@201
41157µs57µsTerm::ReadLine::Tk::::CORE:print Term::ReadLine::Tk::CORE:print (opcode)
11135µs79µsTerm::ReadLine::Stub::::findConsole Term::ReadLine::Stub::findConsole
11117µs17µsTerm::ReadLine::Stub::::CORE:ftis Term::ReadLine::Stub::CORE:ftis (opcode)
33110µs10µsTerm::ReadLine::Stub::::ReadLine Term::ReadLine::Stub::ReadLine
2219µs9µsTerm::ReadLine::Stub::::CORE:select Term::ReadLine::Stub::CORE:select (opcode)
1112µs2µsTerm::ReadLine::Stub::::Features Term::ReadLine::Stub::Features
0000s0sTerm::ReadLine::Stub::::Attribs Term::ReadLine::Stub::Attribs
0000s0sTerm::ReadLine::Stub::::IN Term::ReadLine::Stub::IN
0000s0sTerm::ReadLine::Stub::::MinLine Term::ReadLine::Stub::MinLine
0000s0sTerm::ReadLine::Stub::::OUT Term::ReadLine::Stub::OUT
0000s0sTerm::ReadLine::Stub::::addhistory Term::ReadLine::Stub::addhistory
0000s0sTerm::ReadLine::Stub::::newTTY Term::ReadLine::Stub::newTTY
0000s0sTerm::ReadLine::Tk::::Tk_loop Term::ReadLine::Tk::Tk_loop
0000s0sTerm::ReadLine::Tk::::__ANON__[:426] Term::ReadLine::Tk::__ANON__[:426]
0000s0sTerm::ReadLine::Tk::::__ANON__[:446] Term::ReadLine::Tk::__ANON__[:446]
0000s0sTerm::ReadLine::Tk::::event_loop Term::ReadLine::Tk::event_loop
0000s0sTerm::ReadLine::Tk::::register_Tk Term::ReadLine::Tk::register_Tk
0000s0sTerm::ReadLine::Tk::::tkRunning Term::ReadLine::Tk::tkRunning
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1=head1 NAME
2
3Term::ReadLine - Perl interface to various C<readline> packages.
4If no real package is found, substitutes stubs instead of basic functions.
5
6=head1 SYNOPSIS
7
8 use Term::ReadLine;
9 my $term = Term::ReadLine->new('Simple Perl calc');
10 my $prompt = "Enter your arithmetic expression: ";
11 my $OUT = $term->OUT || \*STDOUT;
12 while ( defined ($_ = $term->readline($prompt)) ) {
13 my $res = eval($_);
14 warn $@ if $@;
15 print $OUT $res, "\n" unless $@;
16 $term->addhistory($_) if /\S/;
17 }
18
19=head1 DESCRIPTION
20
21This package is just a front end to some other packages. It's a stub to
22set up a common interface to the various ReadLine implementations found on
23CPAN (under the C<Term::ReadLine::*> namespace).
24
25=head1 Minimal set of supported functions
26
27All the supported functions should be called as methods, i.e., either as
28
29 $term = Term::ReadLine->new('name');
30
31or as
32
33 $term->addhistory('row');
34
35where $term is a return value of Term::ReadLine-E<gt>new().
36
37=over 12
38
39=item C<ReadLine>
40
41returns the actual package that executes the commands. Among possible
42values are C<Term::ReadLine::Gnu>, C<Term::ReadLine::Perl>,
43C<Term::ReadLine::Stub>.
44
45=item C<new>
46
47returns the handle for subsequent calls to following
48functions. Argument is the name of the application. Optionally can be
49followed by two arguments for C<IN> and C<OUT> filehandles. These
50arguments should be globs.
51
52=item C<readline>
53
54gets an input line, I<possibly> with actual C<readline>
55support. Trailing newline is removed. Returns C<undef> on C<EOF>.
56
57=item C<addhistory>
58
59adds the line to the history of input, from where it can be used if
60the actual C<readline> is present.
61
62=item C<IN>, C<OUT>
63
64return the filehandles for input and output or C<undef> if C<readline>
65input and output cannot be used for Perl.
66
67=item C<MinLine>
68
69If argument is specified, it is an advice on minimal size of line to
70be included into history. C<undef> means do not include anything into
71history. Returns the old value.
72
73=item C<findConsole>
74
75returns an array with two strings that give most appropriate names for
76files for input and output using conventions C<"E<lt>$in">, C<"E<gt>out">.
77
78=item Attribs
79
80returns a reference to a hash which describes internal configuration
81of the package. Names of keys in this hash conform to standard
82conventions with the leading C<rl_> stripped.
83
84=item C<Features>
85
86Returns a reference to a hash with keys being features present in
87current implementation. Several optional features are used in the
88minimal interface: C<appname> should be present if the first argument
89to C<new> is recognized, and C<minline> should be present if
90C<MinLine> method is not dummy. C<autohistory> should be present if
91lines are put into history automatically (maybe subject to
92C<MinLine>), and C<addhistory> if C<addhistory> method is not dummy.
93
94If C<Features> method reports a feature C<attribs> as present, the
95method C<Attribs> is not dummy.
96
97=back
98
99=head1 Additional supported functions
100
101Actually C<Term::ReadLine> can use some other package, that will
102support a richer set of commands.
103
104All these commands are callable via method interface and have names
105which conform to standard conventions with the leading C<rl_> stripped.
106
107The stub package included with the perl distribution allows some
108additional methods:
109
110=over 12
111
112=item C<tkRunning>
113
114makes Tk event loop run when waiting for user input (i.e., during
115C<readline> method).
116
117=item C<event_loop>
118
119Registers call-backs to wait for user input (i.e., during C<readline>
120method). This supersedes tkRunning.
121
122The first call-back registered is the call back for waiting. It is
123expected that the callback will call the current event loop until
124there is something waiting to get on the input filehandle. The parameter
125passed in is the return value of the second call back.
126
127The second call-back registered is the call back for registration. The
128input filehandle (often STDIN, but not necessarily) will be passed in.
129
130For example, with AnyEvent:
131
132 $term->event_loop(sub {
133 my $data = shift;
134 $data->[1] = AE::cv();
135 $data->[1]->recv();
136 }, sub {
137 my $fh = shift;
138 my $data = [];
139 $data->[0] = AE::io($fh, 0, sub { $data->[1]->send() });
140 $data;
141 });
142
143The second call-back is optional if the call back is registered prior to
144the call to $term-E<gt>readline.
145
146Deregistration is done in this case by calling event_loop with C<undef>
147as its parameter:
148
149 $term->event_loop(undef);
150
151This will cause the data array ref to be removed, allowing normal garbage
152collection to clean it up. With AnyEvent, that will cause $data->[0] to
153be cleaned up, and AnyEvent will automatically cancel the watcher at that
154time. If another loop requires more than that to clean up a file watcher,
155that will be up to the caller to handle.
156
157=item C<ornaments>
158
159makes the command line stand out by using termcap data. The argument
160to C<ornaments> should be 0, 1, or a string of a form
161C<"aa,bb,cc,dd">. Four components of this string should be names of
162I<terminal capacities>, first two will be issued to make the prompt
163standout, last two to make the input line standout.
164
165=item C<newTTY>
166
167takes two arguments which are input filehandle and output filehandle.
168Switches to use these filehandles.
169
170=back
171
172One can check whether the currently loaded ReadLine package supports
173these methods by checking for corresponding C<Features>.
174
175=head1 EXPORTS
176
177None
178
179=head1 ENVIRONMENT
180
181The environment variable C<PERL_RL> governs which ReadLine clone is
182loaded. If the value is false, a dummy interface is used. If the value
183is true, it should be tail of the name of the package to use, such as
184C<Perl> or C<Gnu>.
185
186As a special case, if the value of this variable is space-separated,
187the tail might be used to disable the ornaments by setting the tail to
188be C<o=0> or C<ornaments=0>. The head should be as described above, say
189
190If the variable is not set, or if the head of space-separated list is
191empty, the best available package is loaded.
192
193 export "PERL_RL=Perl o=0" # Use Perl ReadLine sans ornaments
194 export "PERL_RL= o=0" # Use best available ReadLine sans ornaments
195
196(Note that processing of C<PERL_RL> for ornaments is in the discretion of the
197particular used C<Term::ReadLine::*> package).
198
199=cut
200
20122.78ms295µs
# spent 77µs (59+18) within CPAN::BEGIN@201 which was called: # once (59µs+18µs) by CPAN::shell at line 201
use strict;
# spent 77µs making 1 call to CPAN::BEGIN@201 # spent 18µs making 1 call to strict::import
202
203package Term::ReadLine::Stub;
204122µsour @ISA = qw'Term::ReadLine::Tk Term::ReadLine::TermCap';
205
20610s$DB::emacs = $DB::emacs; # To pacify -w
207our @rl_term_set;
20813µs*rl_term_set = \@Term::ReadLine::TermCap::rl_term_set;
209
210sub PERL_UNICODE_STDIN () { 0x0001 }
211
212314µs
# spent 10µs within Term::ReadLine::Stub::ReadLine which was called 3 times, avg 3µs/call: # once (5µs+0s) by CPAN::shell at line 310 of CPAN.pm # once (4µs+0s) by CPAN::shell at line 276 of CPAN.pm # once (1µs+0s) by CPAN::shell at line 312 of CPAN.pm
sub ReadLine {'Term::ReadLine::Stub'}
213
# spent 20.4s (223µs+20.4) within Term::ReadLine::Stub::readline which was called 4 times, avg 5.10s/call: # 4 times (223µs+20.4s) by CPAN::shell at line 340 of CPAN.pm, avg 5.10s/call
sub readline {
21447µs my $self = shift;
21547µs my ($in,$out,$str) = @$self;
21640s my $prompt = shift;
2174220µs8311µs print $out $rl_term_set[0], $prompt, $rl_term_set[1], $rl_term_set[2];
# spent 247µs making 4 calls to Term::ReadLine::Stub::CORE:print, avg 62µs/call # spent 64µs making 4 calls to CPAN::Prompt::as_string, avg 16µs/call
21846µs $self->register_Tk
219 if not $Term::ReadLine::registered and $Term::ReadLine::toloop;
220 #$str = scalar <$in>;
221455µs420.4s $str = $self->get_line;
# spent 20.4s making 4 calls to Term::ReadLine::Tk::get_line, avg 5.10s/call
222410µs utf8::upgrade($str)
223 if (${^UNICODE} & PERL_UNICODE_STDIN || defined ${^ENCODING}) &&
224 utf8::valid($str);
225460µs432µs print $out $rl_term_set[3];
# spent 32µs making 4 calls to Term::ReadLine::Stub::CORE:print, avg 8µs/call
226 # bug in 5.000: chomping empty string creates length -1:
22745µs chomp $str if defined $str;
228432µs $str;
229}
230sub addhistory {}
231
232
# spent 79µs (35+44) within Term::ReadLine::Stub::findConsole which was called: # once (35µs+44µs) by Term::ReadLine::Stub::new at line 267
sub findConsole {
23311µs my $console;
234 my $consoleOUT;
235
236127µs117µs if ($^O ne 'MSWin32' and -e "/dev/tty") {
# spent 17µs making 1 call to Term::ReadLine::Stub::CORE:ftis
237 $console = "/dev/tty";
238 } elsif ($^O eq 'MSWin32' or $^O eq 'msys' or -e "con") {
239 $console = 'CONIN$';
240 $consoleOUT = 'CONOUT$';
241 } elsif ($^O eq 'VMS') {
242 $console = "sys\$command";
243 } elsif ($^O eq 'os2' && !$DB::emacs) {
244 $console = "/dev/con";
245 } else {
246 $console = undef;
247 }
248
24910s $consoleOUT = $console unless defined $consoleOUT;
25010s $console = "&STDIN" unless defined $console;
251137µs127µs if ($console eq "/dev/tty" && !open(my $fh, "<", $console)) {
# spent 27µs making 1 call to Term::ReadLine::Stub::CORE:open
252 $console = "&STDIN";
253 undef($consoleOUT);
254 }
25511µs if (!defined $consoleOUT) {
256 $consoleOUT = defined fileno(STDERR) && $^O ne 'MSWin32' ? "&STDERR" : "&STDOUT";
257 }
258118µs ($console,$consoleOUT);
259}
260
261
# spent 49.3ms (75µs+49.3) within Term::ReadLine::Stub::new which was called: # once (75µs+49.3ms) by CPAN::shell at line 274 of CPAN.pm
sub new {
26211µs die "method new called with wrong number of arguments"
263 unless @_==2 or @_==4;
264 #local (*FIN, *FOUT);
26510s my ($FIN, $FOUT, $ret);
26611µs if (@_==2) {
26713µs179µs my($console, $consoleOUT) = $_[0]->findConsole;
# spent 79µs making 1 call to Term::ReadLine::Stub::findConsole
268
269
270 # the Windows CONIN$ needs GENERIC_WRITE mode to allow
271 # a SetConsoleMode() if we end up using Term::ReadKey
272120µs114µs open FIN, (( $^O eq 'MSWin32' && $console eq 'CONIN$' ) ? '+<' : '<' ), $console;
# spent 14µs making 1 call to Term::ReadLine::Stub::CORE:open
273151µs145µs open FOUT,'>', $consoleOUT;
# spent 45µs making 1 call to Term::ReadLine::Stub::CORE:open
274
275 #OUT->autoflush(1); # Conflicts with debugger?
276116µs17µs my $sel = select(FOUT);
# spent 7µs making 1 call to Term::ReadLine::Stub::CORE:select
27714µs $| = 1; # for DB::OUT
27816µs12µs select($sel);
# spent 2µs making 1 call to Term::ReadLine::Stub::CORE:select
27913µs $ret = bless [\*FIN, \*FOUT];
280 } else { # Filehandles supplied
281 $FIN = $_[2]; $FOUT = $_[3];
282 #OUT->autoflush(1); # Conflicts with debugger?
283 my $sel = select($FOUT);
284 $| = 1; # for DB::OUT
285 select($sel);
286 $ret = bless [$FIN, $FOUT];
287 }
28817µs12µs if ($ret->Features->{ornaments}
# spent 2µs making 1 call to Term::ReadLine::Stub::Features
289 and not ($ENV{PERL_RL} and $ENV{PERL_RL} =~ /\bo\w*=0/)) {
29010s local $Term::ReadLine::termcap_nowarn = 1;
29119µs149.1ms $ret->ornaments(1);
# spent 49.1ms making 1 call to Term::ReadLine::TermCap::ornaments
292 }
29319µs return $ret;
294}
295
296sub newTTY {
297 my ($self, $in, $out) = @_;
298 $self->[0] = $in;
299 $self->[1] = $out;
300 my $sel = select($out);
301 $| = 1; # for DB::OUT
302 select($sel);
303}
304
305sub IN { shift->[0] }
306sub OUT { shift->[1] }
307sub MinLine { undef }
308sub Attribs { {} }
309
31012µsmy %features = (tkRunning => 1, ornaments => 1, 'newTTY' => 1);
31118µs
# spent 2µs within Term::ReadLine::Stub::Features which was called: # once (2µs+0s) by Term::ReadLine::Stub::new at line 288
sub Features { \%features }
312
313#sub get_line {
314# my $self = shift;
315# my $in = $self->IN;
316# local ($/) = "\n";
317# return scalar <$in>;
318#}
319
320package Term::ReadLine; # So late to allow the above code be defined?
321
32210sour $VERSION = '1.16';
323
32412µsmy ($which) = exists $ENV{PERL_RL} ? split /\s+/, $ENV{PERL_RL} : undef;
32516µsif ($which) {
326 if ($which =~ /\bgnu\b/i){
327 eval "use Term::ReadLine::Gnu;";
328 } elsif ($which =~ /\bperl\b/i) {
329 eval "use Term::ReadLine::Perl;";
330 } elsif ($which =~ /^(Stub|TermCap|Tk)$/) {
331 # it is already in memory to avoid false exception as seen in:
332 # PERL_RL=Stub perl -e'$SIG{__DIE__} = sub { print @_ }; require Term::ReadLine'
333 } else {
334 eval "use Term::ReadLine::$which;";
335 }
336} elsif (defined $which and $which ne '') { # Defined but false
337 # Do nothing fancy
338} else {
339152µs eval "use Term::ReadLine::Gnu; 1" or eval "use Term::ReadLine::EditLine; 1" or eval "use Term::ReadLine::Perl; 1";
# spent 160µs executing statements in string eval
# includes 66µs spent executing 1 call to 1 sub defined therein. # spent 77µs executing statements in string eval
# includes 36µs spent executing 1 call to 1 sub defined therein. # spent 45µs executing statements in string eval
# includes 37µs spent executing 1 call to 1 sub defined therein.
340}
341
342#require FileHandle;
343
344# To make possible switch off RL in debugger: (Not needed, work done
345# in debugger).
346our @ISA;
34712µsif (defined &Term::ReadLine::Gnu::readline) {
348 @ISA = qw(Term::ReadLine::Gnu Term::ReadLine::Stub);
349} elsif (defined &Term::ReadLine::EditLine::readline) {
350 @ISA = qw(Term::ReadLine::EditLine Term::ReadLine::Stub);
351} elsif (defined &Term::ReadLine::Perl::readline) {
352 @ISA = qw(Term::ReadLine::Perl Term::ReadLine::Stub);
353} elsif (defined $which && defined &{"Term::ReadLine::$which\::readline"}) {
354 @ISA = "Term::ReadLine::$which";
355} else {
35619µs @ISA = qw(Term::ReadLine::Stub);
357}
358
359package Term::ReadLine::TermCap;
360
361# Prompt-start, prompt-end, command-line-start, command-line-end
362# -- zero-width beautifies to emit around prompt and the command line.
36311µsour @rl_term_set = ("","","","");
364# string encoded:
36510sour $rl_term_set = ',,,';
366
367our $terminal;
368
# spent 49.0ms (5.06+43.9) within Term::ReadLine::TermCap::LoadTermCap which was called 3 times, avg 16.3ms/call: # 3 times (5.06ms+43.9ms) by Term::ReadLine::TermCap::ornaments at line 382, avg 16.3ms/call
sub LoadTermCap {
369310µs return if defined $terminal;
370
3711522µs require Term::Cap;
372119µs143.7ms $terminal = Tgetent Term::Cap ({OSPEED => 9600}); # Avoid warning.
# spent 43.7ms making 1 call to Term::Cap::Tgetent
373}
374
375
# spent 49.3ms (179µs+49.1) within Term::ReadLine::TermCap::ornaments which was called 3 times, avg 16.4ms/call: # once (47µs+49.1ms) by Term::ReadLine::Stub::new at line 291 # once (92µs+23µs) by CPAN::shell at line 294 of CPAN.pm # once (40µs+24µs) by CPAN::shell at line 454 of CPAN.pm
sub ornaments {
37632µs shift;
37732µs return $rl_term_set unless @_;
37836µs $rl_term_set = shift;
37932µs $rl_term_set ||= ',,,';
38033µs $rl_term_set = 'us,ue,md,me' if $rl_term_set eq '1';
381311µs my @ts = split /,/, $rl_term_set, 4;
38266µs349.0ms eval { LoadTermCap };
# spent 49.0ms making 3 calls to Term::ReadLine::TermCap::LoadTermCap, avg 16.3ms/call
38331µs unless (defined $terminal) {
384 warn("Cannot find termcap: $@\n") unless $Term::ReadLine::termcap_nowarn;
385 $rl_term_set = ',,,';
386 return;
387 }
3881567µs12112µs @rl_term_set = map {$_ ? $terminal->Tputs($_,1) || '' : ''} @ts;
# spent 112µs making 12 calls to Term::Cap::Tputs, avg 9µs/call
389334µs return $rl_term_set;
390}
391
392
393package Term::ReadLine::Tk;
394
395# This package inserts a Tk->fileevent() before the diamond operator.
396# The Tk watcher dispatches Tk events until the filehandle returned by
397# the$term->IN() accessor becomes ready for reading. It's assumed
398# that the diamond operator will return a line of input immediately at
399# that point.
400
40110smy ($giveup);
402
403# maybe in the future the Tk-specific aspects will be removed.
404sub Tk_loop{
405 if (ref $Term::ReadLine::toloop)
406 {
407 $Term::ReadLine::toloop->[0]->($Term::ReadLine::toloop->[2]);
408 }
409 else
410 {
411 Tk::DoOneEvent(0) until $giveup;
412 $giveup = 0;
413 }
414};
415
416sub register_Tk {
417 my $self = shift;
418 unless ($Term::ReadLine::registered++)
419 {
420 if (ref $Term::ReadLine::toloop)
421 {
422 $Term::ReadLine::toloop->[2] = $Term::ReadLine::toloop->[1]->($self->IN) if $Term::ReadLine::toloop->[1];
423 }
424 else
425 {
426 Tk->fileevent($self->IN,'readable',sub { $giveup = 1});
427 }
428 }
429};
430
431sub tkRunning {
432 $Term::ReadLine::toloop = $_[1] if @_ > 1;
433 $Term::ReadLine::toloop;
434}
435
436sub event_loop {
437 shift;
438
439 # T::RL::Gnu and T::RL::Perl check that this exists, if not,
440 # it doesn't call the loop. Those modules will need to be
441 # fixed before this can be removed.
442 if (not defined &Tk::DoOneEvent)
443 {
444 *Tk::DoOneEvent = sub {
445 die "what?"; # this shouldn't be called.
446 }
447 }
448
449 # store the callback in toloop, again so that other modules will
450 # recognise it and call us for the loop.
451 $Term::ReadLine::toloop = [ @_ ] if @_ > 0; # 0 because we shifted off $self.
452 $Term::ReadLine::toloop;
453}
454
455sub PERL_UNICODE_STDIN () { 0x0001 }
456
457
# spent 20.4s (277µs+20.4) within Term::ReadLine::Tk::get_line which was called 4 times, avg 5.10s/call: # 4 times (277µs+20.4s) by Term::ReadLine::Stub::readline at line 221, avg 5.10s/call
sub get_line {
458412µs my $self = shift;
45943µs my ($in,$out,$str) = @$self;
460
46142µs if ($Term::ReadLine::toloop) {
462 $self->register_Tk if not $Term::ReadLine::registered;
463 $self->Tk_loop;
464 }
465
466425µs local ($/) = "\n";
467420.4s420.4s $str = <$in>;
# spent 20.4s making 4 calls to Term::ReadLine::Tk::CORE:readline, avg 5.10s/call
468
469427µs utf8::upgrade($str)
470 if (${^UNICODE} & PERL_UNICODE_STDIN || defined ${^ENCODING}) &&
471 utf8::valid($str);
4724105µs457µs print $out $rl_term_set[3];
# spent 57µs making 4 calls to Term::ReadLine::Tk::CORE:print, avg 14µs/call
473 # bug in 5.000: chomping empty string creates length -1:
47447µs chomp $str if defined $str;
475
476488µs $str;
477}
478
479129µs1;
480
 
# spent 17µs within Term::ReadLine::Stub::CORE:ftis which was called: # once (17µs+0s) by Term::ReadLine::Stub::findConsole at line 236
sub Term::ReadLine::Stub::CORE:ftis; # opcode
# spent 86µs within Term::ReadLine::Stub::CORE:open which was called 3 times, avg 29µs/call: # once (45µs+0s) by Term::ReadLine::Stub::new at line 273 # once (27µs+0s) by Term::ReadLine::Stub::findConsole at line 251 # once (14µs+0s) by Term::ReadLine::Stub::new at line 272
sub Term::ReadLine::Stub::CORE:open; # opcode
# spent 279µs (215+64) within Term::ReadLine::Stub::CORE:print which was called 8 times, avg 35µs/call: # 4 times (183µs+64µs) by Term::ReadLine::Stub::readline at line 217, avg 62µs/call # 4 times (32µs+0s) by Term::ReadLine::Stub::readline at line 225, avg 8µs/call
sub Term::ReadLine::Stub::CORE:print; # opcode
# spent 9µs within Term::ReadLine::Stub::CORE:select which was called 2 times, avg 4µs/call: # once (7µs+0s) by Term::ReadLine::Stub::new at line 276 # once (2µs+0s) by Term::ReadLine::Stub::new at line 278
sub Term::ReadLine::Stub::CORE:select; # opcode
# spent 57µs within Term::ReadLine::Tk::CORE:print which was called 4 times, avg 14µs/call: # 4 times (57µs+0s) by Term::ReadLine::Tk::get_line at line 472, avg 14µs/call
sub Term::ReadLine::Tk::CORE:print; # opcode
# spent 20.4s within Term::ReadLine::Tk::CORE:readline which was called 4 times, avg 5.10s/call: # 4 times (20.4s+0s) by Term::ReadLine::Tk::get_line at line 467, avg 5.10s/call
sub Term::ReadLine::Tk::CORE:readline; # opcode
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.