← Index
NYTProf Performance Profile   « line view »
For ../prof.pl
  Run on Wed Dec 14 15:33:55 2022
Reported on Wed Dec 14 15:40:04 2022

Filename/Users/ether/.perlbrew/libs/36.0@std/lib/perl5/YAML/PP/Lexer.pm
StatementsExecuted 3206241 statements in 3.10s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
61685101769ms889msYAML::PP::Lexer::::_push_tokens YAML::PP::Lexer::_push_tokens
2792631517ms1.08sYAML::PP::Lexer::::_fetch_next_tokens YAML::PP::Lexer::_fetch_next_tokens
1888411450ms1.86sYAML::PP::Lexer::::fetch_plain YAML::PP::Lexer::fetch_plain
1849731222ms355msYAML::PP::Lexer::::_fetch_next_line YAML::PP::Lexer::_fetch_next_line
1345111211ms1.00sYAML::PP::Lexer::::fetch_next_tokens YAML::PP::Lexer::fetch_next_tokens
58874191201ms201msYAML::PP::Lexer::::CORE:regcomp YAML::PP::Lexer::CORE:regcomp (opcode)
75666161181ms181msYAML::PP::Lexer::::CORE:subst YAML::PP::Lexer::CORE:subst (opcode)
16078422180.5ms80.5msYAML::PP::Lexer::::line YAML::PP::Lexer::line
20561166.3ms251msYAML::PP::Lexer::::fetch_quoted YAML::PP::Lexer::fetch_quoted
20572159.7ms64.1msYAML::PP::Lexer::::push_subtokens YAML::PP::Lexer::push_subtokens
20561144.1ms59.1msYAML::PP::Lexer::::_read_quoted_tokens YAML::PP::Lexer::_read_quoted_tokens
637422138.1ms38.1msYAML::PP::Lexer::::set_offset YAML::PP::Lexer::set_offset
771944237.6ms37.6msYAML::PP::Lexer::::next_tokens YAML::PP::Lexer::next_tokens
762157236.5ms36.5msYAML::PP::Lexer::::flowcontext YAML::PP::Lexer::flowcontext
637422128.1ms28.1msYAML::PP::Lexer::::offset YAML::PP::Lexer::offset
134562124.7ms24.7msYAML::PP::Lexer::::CORE:match YAML::PP::Lexer::CORE:match (opcode)
394384119.7ms19.7msYAML::PP::Lexer::::next_line YAML::PP::Lexer::next_line
374751119.5ms19.5msYAML::PP::Lexer::::context YAML::PP::Lexer::context
269118117.3ms17.3msYAML::PP::Lexer::::set_next_line YAML::PP::Lexer::set_next_line
13455118.54ms8.54msYAML::PP::Lexer::::inc_line YAML::PP::Lexer::inc_line
13455118.24ms8.24msYAML::PP::Lexer::::set_block YAML::PP::Lexer::set_block
13456117.55ms7.55msYAML::PP::Lexer::::reader YAML::PP::Lexer::reader
14025116.92ms6.92msYAML::PP::Lexer::::block YAML::PP::Lexer::block
1114.17ms4.47msYAML::PP::Lexer::::BEGIN@10 YAML::PP::Lexer::BEGIN@10
1102111.06ms1.06msYAML::PP::Lexer::::set_flowcontext YAML::PP::Lexer::set_flowcontext
17621176µs176µsYAML::PP::Lexer::::set_context YAML::PP::Lexer::set_context
111135µs423µsYAML::PP::Lexer::::fetch_block YAML::PP::Lexer::fetch_block
11189µs158µsYAML::PP::Parser::::BEGIN@2.285YAML::PP::Parser::BEGIN@2.285
11129µs33µsYAML::PP::Parser::::BEGIN@1YAML::PP::Parser::BEGIN@1
33214µs14µsYAML::PP::Lexer::::init YAML::PP::Lexer::init
118111µs11µsYAML::PP::Lexer::::CORE:qr YAML::PP::Lexer::CORE:qr (opcode)
11110µs32µsYAML::PP::Lexer::::BEGIN@11 YAML::PP::Lexer::BEGIN@11
11110µs59µsYAML::PP::Lexer::::BEGIN@7 YAML::PP::Lexer::BEGIN@7
1118µs33µsYAML::PP::Lexer::::BEGIN@8 YAML::PP::Lexer::BEGIN@8
1115µs13µsYAML::PP::Lexer::::new YAML::PP::Lexer::new
1114µs4µsYAML::PP::Lexer::::set_reader YAML::PP::Lexer::set_reader
0000s0sYAML::PP::Lexer::::_fetch_next_tokens_directive YAML::PP::Lexer::_fetch_next_tokens_directive
0000s0sYAML::PP::Lexer::::_read_doublequoted YAML::PP::Lexer::_read_doublequoted
0000s0sYAML::PP::Lexer::::exception YAML::PP::Lexer::exception
0000s0sYAML::PP::Lexer::::set_line YAML::PP::Lexer::set_line
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
12104µs237µs
# spent 33µs (29+4) within YAML::PP::Parser::BEGIN@1 which was called: # once (29µs+4µs) by YAML::PP::Parser::BEGIN@18 at line 1
use strict;
# spent 33µs making 1 call to YAML::PP::Parser::BEGIN@1 # spent 4µs making 1 call to strict::import
2283µs2227µs
# spent 158µs (89+69) within YAML::PP::Parser::BEGIN@2.285 which was called: # once (89µs+69µs) by YAML::PP::Parser::BEGIN@18 at line 2
use warnings;
# spent 158µs making 1 call to YAML::PP::Parser::BEGIN@2.285 # spent 69µs making 1 call to warnings::import
3package YAML::PP::Lexer;
4
511µsour $VERSION = '0.035'; # VERSION
6
7239µs2108µs
# spent 59µs (10+49) within YAML::PP::Lexer::BEGIN@7 which was called: # once (10µs+49µs) by YAML::PP::Parser::BEGIN@18 at line 7
use constant TRACE => $ENV{YAML_PP_TRACE} ? 1 : 0;
# spent 59µs making 1 call to YAML::PP::Lexer::BEGIN@7 # spent 49µs making 1 call to constant::import
8228µs258µs
# spent 33µs (8+25) within YAML::PP::Lexer::BEGIN@8 which was called: # once (8µs+25µs) by YAML::PP::Parser::BEGIN@18 at line 8
use constant DEBUG => ($ENV{YAML_PP_DEBUG} || $ENV{YAML_PP_TRACE}) ? 1 : 0;
# spent 33µs making 1 call to YAML::PP::Lexer::BEGIN@8 # spent 25µs making 1 call to constant::import
9
102609µs24.60ms
# spent 4.47ms (4.17+307µs) within YAML::PP::Lexer::BEGIN@10 which was called: # once (4.17ms+307µs) by YAML::PP::Parser::BEGIN@18 at line 10
use YAML::PP::Grammar qw/ $GRAMMAR /;
# spent 4.47ms making 1 call to YAML::PP::Lexer::BEGIN@10 # spent 128µs making 1 call to Exporter::import
1125.54ms254µs
# spent 32µs (10+22) within YAML::PP::Lexer::BEGIN@11 which was called: # once (10µs+22µs) by YAML::PP::Parser::BEGIN@18 at line 11
use Carp qw/ croak /;
# spent 32µs making 1 call to YAML::PP::Lexer::BEGIN@11 # spent 22µs making 1 call to Exporter::import
12
13
# spent 13µs (5+8) within YAML::PP::Lexer::new which was called: # once (5µs+8µs) by YAML::PP::Parser::new at line 29 of YAML/PP/Parser.pm
sub new {
1411µs my ($class, %args) = @_;
15 my $self = bless {
16 reader => $args{reader},
1711µs }, $class;
1811µs18µs $self->init;
# spent 8µs making 1 call to YAML::PP::Lexer::init
1913µs return $self;
20}
21
22
# spent 14µs within YAML::PP::Lexer::init which was called 3 times, avg 5µs/call: # once (8µs+0s) by YAML::PP::Lexer::new at line 18 # once (3µs+0s) by YAML::PP::Parser::parse at line 151 of YAML/PP/Parser.pm # once (3µs+0s) by YAML::PP::Parser::init at line 115 of YAML/PP/Parser.pm
sub init {
2332µs my ($self) = @_;
2433µs $self->{next_tokens} = [];
2530s $self->{next_line} = undef;
2632µs $self->{line} = 0;
2730s $self->{offset} = 0;
28315µs $self->{flowcontext} = 0;
29}
30
313943854.7ms
# spent 19.7ms within YAML::PP::Lexer::next_line which was called 39438 times, avg 500ns/call: # 18884 times (10.0ms+0s) by YAML::PP::Lexer::fetch_plain at line 367, avg 530ns/call # 18497 times (8.61ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 136, avg 465ns/call # 2056 times (1.09ms+0s) by YAML::PP::Lexer::fetch_quoted at line 620, avg 530ns/call # once (0s+0s) by YAML::PP::Lexer::fetch_block at line 519
sub next_line { return $_[0]->{next_line} }
322691143.0ms
# spent 17.3ms within YAML::PP::Lexer::set_next_line which was called 26911 times, avg 643ns/call: # 13455 times (8.03ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 150, avg 597ns/call # 6386 times (4.25ms+0s) by YAML::PP::Lexer::fetch_plain at line 398, avg 665ns/call # 5040 times (3.49ms+0s) by YAML::PP::Lexer::fetch_plain at line 392, avg 693ns/call # 1424 times (1.08ms+0s) by YAML::PP::Lexer::fetch_quoted at line 706, avg 761ns/call # 598 times (435µs+0s) by YAML::PP::Lexer::fetch_quoted at line 697, avg 727ns/call # 6 times (4µs+0s) by YAML::PP::Lexer::fetch_block at line 561, avg 667ns/call # once (1µs+0s) by YAML::PP::Lexer::_fetch_next_line at line 143 # once (0s+0s) by YAML::PP::Lexer::fetch_next_tokens at line 221
sub set_next_line { $_[0]->{next_line} = $_[1] }
331345618.0ms
# spent 7.55ms within YAML::PP::Lexer::reader which was called 13456 times, avg 561ns/call: # 13456 times (7.55ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 141, avg 561ns/call
sub reader { return $_[0]->{reader} }
3415µs
# spent 4µs within YAML::PP::Lexer::set_reader which was called: # once (4µs+0s) by YAML::PP::Parser::set_reader at line 70 of YAML/PP/Parser.pm
sub set_reader { $_[0]->{reader} = $_[1] }
3577194111ms
# spent 37.6ms within YAML::PP::Lexer::next_tokens which was called 77194 times, avg 487ns/call: # 61685 times (30.1ms+0s) by YAML::PP::Lexer::_push_tokens at line 880, avg 488ns/call # 13451 times (6.39ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 182, avg 475ns/call # 2057 times (1.12ms+0s) by YAML::PP::Lexer::push_subtokens at line 906, avg 542ns/call # once (1µs+0s) by YAML::PP::Parser::parse_tokens at line 344 of YAML/PP/Parser.pm
sub next_tokens { return $_[0]->{next_tokens} }
36160784216ms
# spent 80.5ms within YAML::PP::Lexer::line which was called 160784 times, avg 500ns/call: # 61685 times (25.8ms+0s) by YAML::PP::Lexer::_push_tokens at line 881, avg 418ns/call # 18884 times (15.0ms+0s) by YAML::PP::Lexer::fetch_plain at line 381, avg 796ns/call # 18884 times (8.64ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 355, avg 458ns/call # 14054 times (6.86ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 295, avg 488ns/call # 13449 times (6.55ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 487ns/call # 7598 times (4.12ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 307, avg 542ns/call # 6456 times (3.37ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 303, avg 522ns/call # 5040 times (2.77ms+0s) by YAML::PP::Lexer::fetch_plain at line 391, avg 549ns/call # 2057 times (916µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 278, avg 445ns/call # 2057 times (884µs+0s) by YAML::PP::Lexer::push_subtokens at line 907, avg 430ns/call # 2056 times (1.29ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 742, avg 629ns/call # 2056 times (1.17ms+0s) by YAML::PP::Lexer::fetch_quoted at line 626, avg 568ns/call # 2056 times (893µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 748, avg 434ns/call # 1791 times (793µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 340, avg 443ns/call # 1424 times (694µs+0s) by YAML::PP::Lexer::fetch_quoted at line 704, avg 487ns/call # 689 times (396µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 336, avg 575ns/call # 529 times (263µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 256, avg 497ns/call # 15 times (10µs+0s) by YAML::PP::Lexer::fetch_block at line 605, avg 667ns/call # once (2µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208 # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 526 # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 538 # once (0s+0s) by YAML::PP::Lexer::fetch_block at line 548
sub line { return $_[0]->{line} }
37sub set_line { $_[0]->{line} = $_[1] }
386374282.4ms
# spent 28.1ms within YAML::PP::Lexer::offset which was called 63742 times, avg 441ns/call: # 61685 times (27.1ms+0s) by YAML::PP::Lexer::_push_tokens at line 882, avg 440ns/call # 2057 times (974µs+0s) by YAML::PP::Lexer::push_subtokens at line 908, avg 474ns/call
sub offset { return $_[0]->{offset} }
3963742114ms
# spent 38.1ms within YAML::PP::Lexer::set_offset which was called 63742 times, avg 597ns/call: # 61685 times (36.6ms+0s) by YAML::PP::Lexer::_push_tokens at line 900, avg 594ns/call # 2057 times (1.43ms+0s) by YAML::PP::Lexer::push_subtokens at line 936, avg 697ns/call
sub set_offset { $_[0]->{offset} = $_[1] }
401345519.4ms
# spent 8.54ms within YAML::PP::Lexer::inc_line which was called 13455 times, avg 635ns/call: # 13455 times (8.54ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 147, avg 635ns/call
sub inc_line { return $_[0]->{line}++ }
413747553.1ms
# spent 19.5ms within YAML::PP::Lexer::context which was called 37475 times, avg 519ns/call: # 37475 times (19.5ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 263, avg 519ns/call
sub context { return $_[0]->{context} }
42176400µs
# spent 176µs within YAML::PP::Lexer::set_context which was called 176 times, avg 1µs/call: # 88 times (120µs+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 1µs/call # 88 times (56µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 275, avg 636ns/call
sub set_context { $_[0]->{context} = $_[1] }
4376215105ms
# spent 36.5ms within YAML::PP::Lexer::flowcontext which was called 76215 times, avg 479ns/call: # 20941 times (9.87ms+0s) by YAML::PP::Parser::parse_tokens at line 379 of YAML/PP/Parser.pm, avg 471ns/call # 18884 times (7.67ms+0s) by YAML::PP::Lexer::fetch_plain at line 371, avg 406ns/call # 14054 times (7.46ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 531ns/call # 13449 times (7.55ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 562ns/call # 5040 times (2.16ms+0s) by YAML::PP::Lexer::fetch_plain at line 405, avg 428ns/call # 2056 times (1.02ms+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 497ns/call # 1791 times (749µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 342, avg 418ns/call
sub flowcontext { return $_[0]->{flowcontext} }
4411022.10ms
# spent 1.06ms within YAML::PP::Lexer::set_flowcontext which was called 1102 times, avg 961ns/call: # 1102 times (1.06ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 343, avg 961ns/call
sub set_flowcontext { $_[0]->{flowcontext} = $_[1] }
451402524.2ms
# spent 6.92ms within YAML::PP::Lexer::block which was called 14025 times, avg 494ns/call: # 14025 times (6.92ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 494ns/call
sub block { return $_[0]->{block} }
461345525.9ms
# spent 8.24ms within YAML::PP::Lexer::set_block which was called 13455 times, avg 612ns/call: # 13455 times (8.24ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 146, avg 612ns/call
sub set_block { $_[0]->{block} = $_[1] }
47
4811µsmy $RE_WS = '[\t ]';
4910smy $RE_LB = '[\r\n]';
50142µs224µsmy $RE_DOC_END = qr/\A(\.\.\.)(?=$RE_WS|$)/m;
# spent 22µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 2µs making 1 call to YAML::PP::Lexer::CORE:qr
51114µs210µsmy $RE_DOC_START = qr/\A(---)(?=$RE_WS|$)/m;
# spent 9µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
52118µs214µsmy $RE_EOL = qr/\A($RE_WS+#.*|$RE_WS+)\z/;
# spent 13µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
53#my $RE_COMMENT_EOL = qr/\A(#.*)?(?:$RE_LB|\z)/;
54
55#ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
5611µsmy $RE_NS_WORD_CHAR = '[0-9A-Za-z-]';
5711µsmy $RE_URI_CHAR = '(?:' . '%[0-9a-fA-F]{2}' .'|'. q{[0-9A-Za-z#;/?:@&=+$,_.!*'\(\)\[\]-]} . ')';
5810smy $RE_NS_TAG_CHAR = '(?:' . '%[0-9a-fA-F]{2}' .'|'. q{[0-9A-Za-z#;/?:@&=+$_.~*'\(\)-]} . ')';
59
60# [#x21-#x7E] /* 8 bit */
61# | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] /* 16 bit */
62# | [#x10000-#x10FFFF] /* 32 bit */
63
64#nb-char ::= c-printable - b-char - c-byte-order-mark
65#my $RE_NB_CHAR = '[\x21-\x7E]';
6611µsmy $RE_ANCHOR_CAR = '[\x21-\x2B\x2D-\x5A\x5C\x5E-\x7A\x7C\x7E\xA0-\xFF\x{100}-\x{10FFFF}]';
67
6810smy $RE_PLAIN_START = '[\x21\x22\x24-\x39\x3B-\x7E\xA0-\xFF\x{100}-\x{10FFFF}]';
6911µsmy $RE_PLAIN_END = '[\x21-\x39\x3B-\x7E\x85\xA0-\x{D7FF}\x{E000}-\x{FEFE}\x{FF00}-\x{FFFD}\x{10000}-\x{10FFFF}]';
7010smy $RE_PLAIN_FIRST = '[\x24\x28-\x29\x2B\x2E-\x39\x3B-\x3D\x41-\x5A\x5C\x5E-\x5F\x61-\x7A\x7E\xA0-\xFF\x{100}-\x{10FFFF}]';
71
7210smy $RE_PLAIN_START_FLOW = '[\x21\x22\x24-\x2B\x2D-\x39\x3B-\x5A\x5C\x5E-\x7A\x7C\x7E\xA0-\xFF\x{100}-\x{10FFFF}]';
7310smy $RE_PLAIN_END_FLOW = '[\x21-\x2B\x2D-\x39\x3B-\x5A\x5C\x5E-\x7A\x7C\x7E\x85\xA0-\x{D7FF}\x{E000}-\x{FEFE}\x{FF00}-\x{FFFD}\x{10000}-\x{10FFFF}]';
7410smy $RE_PLAIN_FIRST_FLOW = '[\x24\x28-\x29\x2B\x2E-\x39\x3B-\x3D\x41-\x5A\x5C\x5E-\x5F\x61-\x7A\x7C\x7E\xA0-\xFF\x{100}-\x{10FFFF}]';
75# c-indicators
76#! 21
77#" 22
78## 23
79#% 25
80#& 26
81#' 27
82#* 2A
83#, 2C FLOW
84#- 2D XX
85#: 3A XX
86#> 3E
87#? 3F XX
88#@ 40
89#[ 5B FLOW
90#] 5D FLOW
91#` 60
92#{ 7B FLOW
93#| 7C
94#} 7D FLOW
95
96
9711µsmy $RE_PLAIN_WORD = "(?::+$RE_PLAIN_END|$RE_PLAIN_START)(?::+$RE_PLAIN_END|$RE_PLAIN_END)*";
9814µsmy $RE_PLAIN_FIRST_WORD = "(?:[:?-]+$RE_PLAIN_END|$RE_PLAIN_FIRST)(?::+$RE_PLAIN_END|$RE_PLAIN_END)*";
9910smy $RE_PLAIN_WORDS = "(?:$RE_PLAIN_FIRST_WORD(?:$RE_WS+$RE_PLAIN_WORD)*)";
10011µsmy $RE_PLAIN_WORDS2 = "(?:$RE_PLAIN_WORD(?:$RE_WS+$RE_PLAIN_WORD)*)";
101
10211µsmy $RE_PLAIN_WORD_FLOW = "(?::+$RE_PLAIN_END_FLOW|$RE_PLAIN_START_FLOW)(?::+$RE_PLAIN_END_FLOW|$RE_PLAIN_END_FLOW)*";
10310smy $RE_PLAIN_FIRST_WORD_FLOW = "(?:[:?-]+$RE_PLAIN_END_FLOW|$RE_PLAIN_FIRST_FLOW)(?::+$RE_PLAIN_END_FLOW|$RE_PLAIN_END_FLOW)*";
10410smy $RE_PLAIN_WORDS_FLOW = "(?:$RE_PLAIN_FIRST_WORD_FLOW(?:$RE_WS+$RE_PLAIN_WORD_FLOW)*)";
10513µsmy $RE_PLAIN_WORDS_FLOW2 = "(?:$RE_PLAIN_WORD_FLOW(?:$RE_WS+$RE_PLAIN_WORD_FLOW)*)";
106
107
108#c-secondary-tag-handle ::= “!” “!”
109#c-named-tag-handle ::= “!” ns-word-char+ “!”
110#ns-tag-char ::= ns-uri-char - “!” - c-flow-indicator
111#ns-global-tag-prefix ::= ns-tag-char ns-uri-char*
112#c-ns-local-tag-prefix ::= “!” ns-uri-char*
11310smy $RE_TAG = "!(?:$RE_NS_WORD_CHAR*!$RE_NS_TAG_CHAR+|$RE_NS_TAG_CHAR+|<$RE_URI_CHAR+>|)";
114
115#c-ns-anchor-property ::= “&” ns-anchor-name
116#ns-char ::= nb-char - s-white
117#ns-anchor-char ::= ns-char - c-flow-indicator
118#ns-anchor-name ::= ns-anchor-char+
119
120116µs29µsmy $RE_SEQSTART = qr/\A(-)(?=$RE_WS|$)/m;
# spent 9µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 0s making 1 call to YAML::PP::Lexer::CORE:qr
121123µs210µsmy $RE_COMPLEX = qr/(\?)(?=$RE_WS|$)/m;
# spent 9µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
122113µs28µsmy $RE_COMPLEXCOLON = qr/\A(:)(?=$RE_WS|$)/m;
# spent 8µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 0s making 1 call to YAML::PP::Lexer::CORE:qr
12310smy $RE_ANCHOR = "&$RE_ANCHOR_CAR+";
12411µsmy $RE_ALIAS = "\\*$RE_ANCHOR_CAR+";
125
126
1271284µs7261µsmy %REGEXES = (
# spent 256µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 85µs/call # spent 5µs making 4 calls to YAML::PP::Lexer::CORE:qr, avg 1µs/call
128 ANCHOR => qr{($RE_ANCHOR)},
129 TAG => qr{($RE_TAG)},
130 ALIAS => qr{($RE_ALIAS)},
131 SINGLEQUOTED => qr{(?:''|[^'\r\n]+)*},
132);
133
134
# spent 355ms (222+133) within YAML::PP::Lexer::_fetch_next_line which was called 18497 times, avg 19µs/call: # 13451 times (147ms+88.4ms) by YAML::PP::Lexer::fetch_next_tokens at line 185, avg 18µs/call # 5040 times (75.2ms+44.1ms) by YAML::PP::Lexer::fetch_plain at line 412, avg 24µs/call # 6 times (82µs+45µs) by YAML::PP::Lexer::fetch_block at line 562, avg 21µs/call
sub _fetch_next_line {
135184973.36ms my ($self) = @_;
1361849712.4ms184978.61ms my $next_line = $self->next_line;
# spent 8.61ms making 18497 calls to YAML::PP::Lexer::next_line, avg 465ns/call
1371849710.9ms if (defined $next_line ) {
138 return $next_line;
139 }
140
1411345625.9ms2691274.5ms my $line = $self->reader->readline;
# spent 67.0ms making 13456 calls to YAML::PP::Reader::File::readline, avg 5µs/call # spent 7.55ms making 13456 calls to YAML::PP::Lexer::reader, avg 561ns/call
142134562.08ms unless (defined $line) {
14311µs11µs $self->set_next_line(undef);
# spent 1µs making 1 call to YAML::PP::Lexer::set_next_line
14411µs return;
145 }
1461345510.3ms134558.24ms $self->set_block(1);
# spent 8.24ms making 13455 calls to YAML::PP::Lexer::set_block, avg 612ns/call
147134559.60ms134558.54ms $self->inc_line;
# spent 8.54ms making 13455 calls to YAML::PP::Lexer::inc_line, avg 635ns/call
1481345544.5ms1345524.7ms $line =~ m/\A( *)([^\r\n]*)([\r\n]|\z)/ or die "Unexpected";
# spent 24.7ms making 13455 calls to YAML::PP::Lexer::CORE:match, avg 2µs/call
1491345523.1ms $next_line = [ $1, $2, $3 ];
150134559.77ms134558.03ms $self->set_next_line($next_line);
# spent 8.03ms making 13455 calls to YAML::PP::Lexer::set_next_line, avg 597ns/call
151 # $ESCAPE_CHAR from YAML.pm
152134556.76ms if ($line =~ tr/\x00-\x08\x0b-\x0c\x0e-\x1f//) {
153 $self->exception("Control characters are not allowed");
154 }
155
1561345531.2ms return $next_line;
157}
158
159110µsmy %TOKEN_NAMES = (
160 '"' => 'DOUBLEQUOTE',
161 "'" => 'SINGLEQUOTE',
162 '|' => 'LITERAL',
163 '>' => 'FOLDED',
164 '!' => 'TAG',
165 '*' => 'ALIAS',
166 '&' => 'ANCHOR',
167 ':' => 'COLON',
168 '-' => 'DASH',
169 '?' => 'QUESTION',
170 '[' => 'FLOWSEQ_START',
171 ']' => 'FLOWSEQ_END',
172 '{' => 'FLOWMAP_START',
173 '}' => 'FLOWMAP_END',
174 ',' => 'FLOW_COMMA',
175 '---' => 'DOC_START',
176 '...' => 'DOC_END',
177);
178
179
180
# spent 1.00s (211ms+790ms) within YAML::PP::Lexer::fetch_next_tokens which was called 13451 times, avg 74µs/call: # 13451 times (211ms+790ms) by YAML::PP::Parser::lex_next_tokens at line 179 of YAML/PP/Parser.pm, avg 74µs/call
sub fetch_next_tokens {
181134512.80ms my ($self) = @_;
182134518.93ms134516.39ms my $next = $self->next_tokens;
# spent 6.39ms making 13451 calls to YAML::PP::Lexer::next_tokens, avg 475ns/call
183134511.87ms return $next if @$next;
184
1851345112.7ms13451236ms my $next_line = $self->_fetch_next_line;
# spent 236ms making 13451 calls to YAML::PP::Lexer::_fetch_next_line, avg 18µs/call
186134511.74ms if (not $next_line) {
187 return [];
188 }
189
190134504.72ms my $spaces = $next_line->[0];
191134504.14ms my $yaml = \$next_line->[1];
192134503.61ms if (not length $$yaml) {
193 $self->_push_tokens([ EOL => join('', @$next_line), $self->line ]);
194 $self->set_next_line(undef);
195 return $next;
196 }
1971345013.1ms if (substr($$yaml, 0, 1) eq '#') {
198 $self->_push_tokens([ EOL => join('', @$next_line), $self->line ]);
199 $self->set_next_line(undef);
200 return $next;
201 }
202134502.55ms if (not $spaces and substr($$yaml, 0, 1) eq "%") {
203 $self->_fetch_next_tokens_directive($yaml, $next_line->[2]);
204 $self->set_context(0);
205 $self->set_next_line(undef);
206 return $next;
207 }
2081345021.9ms134637.64ms if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 7.55ms making 13449 calls to YAML::PP::Lexer::flowcontext, avg 562ns/call # spent 49µs making 6 calls to YAML::PP::Lexer::CORE:regcomp, avg 8µs/call # spent 34µs making 1 call to YAML::PP::Lexer::_push_tokens # spent 7µs making 6 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 2µs making 1 call to YAML::PP::Lexer::line
209 $self->_push_tokens([ $TOKEN_NAMES{ $1 } => $1, $self->line ]);
210 }
211 elsif ($self->flowcontext and $$yaml =~ m/\A[ \t]+(#.*)?\z/) {
212 $self->_push_tokens([ EOL => join('', @$next_line), $self->line ]);
213 $self->set_next_line(undef);
214 return $next;
215 }
216 else {
2171344924.9ms26898192ms $self->_push_tokens([ SPACE => $spaces, $self->line ]);
# spent 185ms making 13449 calls to YAML::PP::Lexer::_push_tokens, avg 14µs/call # spent 6.55ms making 13449 calls to YAML::PP::Lexer::line, avg 487ns/call
218 }
219
2201345012.2ms13450348ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 348ms making 13450 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 26µs/call
221134501.75ms10s unless ($partial) {
# spent 0s making 1 call to YAML::PP::Lexer::set_next_line
222 $self->set_next_line(undef);
223 }
2241345024.4ms return $next;
225}
226
22711µsmy %ANCHOR_ALIAS_TAG = ( '&' => 1, '*' => 1, '!' => 1 );
22811µsmy %BLOCK_SCALAR = ( '|' => 1, '>' => 1 );
229112µsmy %COLON_DASH_QUESTION = ( ':' => 1, '-' => 1, '?' => 1 );
23012µsmy %QUOTED = ( '"' => 1, "'" => 1 );
23111µsmy %FLOW = ( '{' => 1, '[' => 1, '}' => 1, ']' => 1, ',' => 1 );
23210smy %CONTEXT = ( '"' => 1, "'" => 1, '>' => 1, '|' => 1 );
233
23414µs11µsmy $RE_ESCAPES = qr{(?:
# spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
235 \\([ \\\/_0abefnrtvLNP\t"]) | \\x([0-9a-fA-F]{2})
236 | \\u([A-Fa-f0-9]{4}) | \\U([A-Fa-f0-9]{4,8})
237)}x;
23819µsmy %CONTROL = (
239 '\\' => '\\', '/' => '/', n => "\n", t => "\t", r => "\r", b => "\b",
240 'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f", 'v' => "\x0b", "\t" => "\t",
241 'P' => "\x{2029}", L => "\x{2028}", 'N' => "\x85",
242 '0' => "\0", '_' => "\xa0", ' ' => ' ', q/"/ => q/"/,
243);
244
245
# spent 1.08s (517ms+558ms) within YAML::PP::Lexer::_fetch_next_tokens which was called 27926 times, avg 38µs/call: # 13844 times (361ms+336ms) by YAML::PP::Lexer::fetch_plain at line 397, avg 50µs/call # 13450 times (141ms+207ms) by YAML::PP::Lexer::fetch_next_tokens at line 220, avg 26µs/call # 632 times (14.9ms+14.6ms) by YAML::PP::Lexer::fetch_quoted at line 696, avg 47µs/call
sub _fetch_next_tokens {
246 TRACE and warn __PACKAGE__.':'.__LINE__.": _fetch_next_tokens\n";
247279265.29ms my ($self, $next_line) = @_;
248
249279267.87ms my $yaml = \$next_line->[1];
250279265.49ms my $eol = $next_line->[2];
251
252279263.35ms my @tokens;
253
254279263.80ms while (1) {
255380047.05ms unless (length $$yaml) {
256529675µs529263µs push @tokens, ( EOL => $eol, $self->line );
# spent 263µs making 529 calls to YAML::PP::Lexer::line, avg 497ns/call
257529514µs52910.3ms $self->_push_tokens(\@tokens);
# spent 10.3ms making 529 calls to YAML::PP::Lexer::_push_tokens, avg 19µs/call
2585291.44ms return;
259 }
2603747515.7ms my $first = substr($$yaml, 0, 1);
261374754.83ms my $plain = 0;
262
2633747526.8ms3747519.5ms if ($self->context) {
# spent 19.5ms making 37475 calls to YAML::PP::Lexer::context, avg 519ns/call
26488421µs176171µs if ($$yaml =~ s/\A($RE_WS*)://) {
# spent 119µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/call # spent 52µs making 88 calls to YAML::PP::Lexer::CORE:subst, avg 591ns/call
265 push @tokens, ( WS => $1, $self->line ) if $1;
266 push @tokens, ( COLON => ':', $self->line );
267 $self->set_context(0);
268 next;
269 }
27088396µs176136µs if ($$yaml =~ s/\A($RE_WS*(?: #.*))\z//) {
# spent 105µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/call # spent 31µs making 88 calls to YAML::PP::Lexer::CORE:subst, avg 352ns/call
271 push @tokens, ( EOL => $1 . $eol, $self->line );
272 $self->_push_tokens(\@tokens);
273 return;
274 }
27588120µs8856µs $self->set_context(0);
# spent 56µs making 88 calls to YAML::PP::Lexer::set_context, avg 636ns/call
276 }
2773747528.9ms if ($CONTEXT{ $first }) {
27820572.96ms2057916µs push @tokens, ( CONTEXT => $first, $self->line );
# spent 916µs making 2057 calls to YAML::PP::Lexer::line, avg 445ns/call
27920571.90ms205732.8ms $self->_push_tokens(\@tokens);
# spent 32.8ms making 2057 calls to YAML::PP::Lexer::_push_tokens, avg 16µs/call
28020574.85ms return 1;
281 }
282 elsif ($COLON_DASH_QUESTION{ $first }) {
283140544.62ms my $token_name = $TOKEN_NAMES{ $first };
28414054106ms2810863.2ms if ($$yaml =~ s/\A\Q$first\E($RE_WS+|\z)//) {
# spent 38.4ms making 14054 calls to YAML::PP::Lexer::CORE:regcomp, avg 3µs/call # spent 24.8ms making 14054 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call
285140545.45ms my $after = $1;
2861405420.0ms2807914.4ms if (not $self->flowcontext and not $self->block) {
# spent 7.46ms making 14054 calls to YAML::PP::Lexer::flowcontext, avg 531ns/call # spent 6.92ms making 14025 calls to YAML::PP::Lexer::block, avg 494ns/call
287 push @tokens, ERROR => $first . $after, $self->line;
288 $self->_push_tokens(\@tokens);
289 $self->exception("Tabs can not be used for indentation");
290 }
291140544.93ms if ($after =~ tr/\t//) {
292 $self->set_block(0);
293 }
294140543.34ms my $token_name = $TOKEN_NAMES{ $first };
2951405416.4ms140546.86ms push @tokens, ( $token_name => $first, $self->line );
# spent 6.86ms making 14054 calls to YAML::PP::Lexer::line, avg 488ns/call
296140544.21ms if (not defined $1) {
297 push @tokens, ( EOL => $eol, $self->line );
298 $self->_push_tokens(\@tokens);
299 return;
300 }
301140544.25ms my $ws = $1;
3021405436.3ms1405416.1ms if ($$yaml =~ s/\A(#.*|)\z//) {
# spent 16.1ms making 14054 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
303645613.3ms64563.37ms push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
# spent 3.37ms making 6456 calls to YAML::PP::Lexer::line, avg 522ns/call
30464565.07ms645698.1ms $self->_push_tokens(\@tokens);
# spent 98.1ms making 6456 calls to YAML::PP::Lexer::_push_tokens, avg 15µs/call
305645621.8ms return;
306 }
307759810.2ms75984.12ms push @tokens, ( WS => $ws, $self->line );
# spent 4.12ms making 7598 calls to YAML::PP::Lexer::line, avg 542ns/call
30875988.60ms next;
309 }
310 elsif ($self->flowcontext and $$yaml =~ s/\A:(?=[,\{\}\[\]])//) {
311 push @tokens, ( $token_name => $first, $self->line );
312 next;
313 }
314 $plain = 1;
315 }
316 elsif ($ANCHOR_ALIAS_TAG{ $first }) {
317 my $token_name = $TOKEN_NAMES{ $first };
318 my $REGEX = $REGEXES{ $token_name };
319 if ($$yaml =~ s/\A$REGEX//) {
320 push @tokens, ( $token_name => $1, $self->line );
321 }
322 else {
323 push @tokens, ( "Invalid $token_name" => $$yaml, $self->line );
324 $self->_push_tokens(\@tokens);
325 return;
326 }
327 }
328 elsif ($first eq ' ' or $first eq "\t") {
3296893.58ms13781.48ms if ($$yaml =~ s/\A($RE_WS+)//) {
# spent 965µs making 689 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 516µs making 689 calls to YAML::PP::Lexer::CORE:regcomp, avg 749ns/call
330689325µs my $ws = $1;
3316891.68ms689684µs if ($$yaml =~ s/\A((?:#.*)?\z)//) {
# spent 684µs making 689 calls to YAML::PP::Lexer::CORE:subst, avg 993ns/call
332 push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
333 $self->_push_tokens(\@tokens);
334 return;
335 }
336689871µs689396µs push @tokens, ( WS => $ws, $self->line );
# spent 396µs making 689 calls to YAML::PP::Lexer::line, avg 575ns/call
337 }
338 }
339 elsif ($FLOW{ $first }) {
34017912.51ms1791793µs push @tokens, ( $TOKEN_NAMES{ $first } => $first, $self->line );
# spent 793µs making 1791 calls to YAML::PP::Lexer::line, avg 443ns/call
34117911.99ms substr($$yaml, 0, 1, '');
34217911.28ms1791749µs my $flowcontext = $self->flowcontext;
# spent 749µs making 1791 calls to YAML::PP::Lexer::flowcontext, avg 418ns/call
34317911.99ms11021.06ms if ($first eq '{' or $first eq '[') {
# spent 1.06ms making 1102 calls to YAML::PP::Lexer::set_flowcontext, avg 961ns/call
344 $self->set_flowcontext(++$flowcontext);
345 }
346 elsif ($first eq '}' or $first eq ']') {
347 $self->set_flowcontext(--$flowcontext);
348 }
349 }
350 else {
351188842.81ms $plain = 1;
352 }
353
354213644.21ms if ($plain) {
3551888418.1ms188848.64ms push @tokens, ( CONTEXT => '', $self->line );
# spent 8.64ms making 18884 calls to YAML::PP::Lexer::line, avg 458ns/call
3561888414.2ms18884274ms $self->_push_tokens(\@tokens);
# spent 274ms making 18884 calls to YAML::PP::Lexer::_push_tokens, avg 15µs/call
3571888441.5ms return 1;
358 }
359
360 }
361
362 return;
363}
364
365
# spent 1.86s (450ms+1.41) within YAML::PP::Lexer::fetch_plain which was called 18884 times, avg 99µs/call: # 18884 times (450ms+1.41s) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 99µs/call
sub fetch_plain {
366188846.55ms my ($self, $indent, $context) = @_;
3671888414.9ms1888410.0ms my $next_line = $self->next_line;
# spent 10.0ms making 18884 calls to YAML::PP::Lexer::next_line, avg 530ns/call
368188845.68ms my $yaml = \$next_line->[1];
369188844.38ms my $eol = $next_line->[2];
370188844.21ms my $REGEX = $RE_PLAIN_WORDS;
3711888411.2ms188847.67ms if ($self->flowcontext) {
# spent 7.67ms making 18884 calls to YAML::PP::Lexer::flowcontext, avg 406ns/call
372 $REGEX = $RE_PLAIN_WORDS_FLOW;
373 }
374
375188842.60ms my @tokens;
37618884300ms37768238ms unless ($$yaml =~ s/\A($REGEX)//) {
# spent 138ms making 18884 calls to YAML::PP::Lexer::CORE:regcomp, avg 7µs/call # spent 100ms making 18884 calls to YAML::PP::Lexer::CORE:subst, avg 5µs/call
377 $self->_push_tokens(\@tokens);
378 $self->exception("Invalid plain scalar");
379 }
3801888412.4ms my $plain = $1;
3811888426.3ms1888415.0ms push @tokens, ( PLAIN => $plain, $self->line );
# spent 15.0ms making 18884 calls to YAML::PP::Lexer::line, avg 796ns/call
382
3831888492.5ms3776841.9ms if ($$yaml =~ s/\A(?:($RE_WS+#.*)|($RE_WS*))\z//) {
# spent 23.9ms making 18884 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 18.0ms making 18884 calls to YAML::PP::Lexer::CORE:regcomp, avg 954ns/call
38450402.67ms if (defined $1) {
385 push @tokens, ( EOL => $1 . $eol, $self->line );
386 $self->_push_tokens(\@tokens);
387 $self->set_next_line(undef);
388 return;
389 }
390 else {
39150408.40ms50402.77ms push @tokens, ( EOL => $2. $eol, $self->line );
# spent 2.77ms making 5040 calls to YAML::PP::Lexer::line, avg 549ns/call
39250404.96ms50403.49ms $self->set_next_line(undef);
# spent 3.49ms making 5040 calls to YAML::PP::Lexer::set_next_line, avg 693ns/call
393 }
394 }
395 else {
3961384412.2ms13844180ms $self->_push_tokens(\@tokens);
# spent 180ms making 13844 calls to YAML::PP::Lexer::_push_tokens, avg 13µs/call
3971384412.3ms13844698ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 698ms making 13844 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 50µs/call
398138447.21ms63864.25ms if (not $partial) {
# spent 4.25ms making 6386 calls to YAML::PP::Lexer::set_next_line, avg 665ns/call
399 $self->set_next_line(undef);
400 }
4011384443.1ms return;
402 }
403
40450401.53ms my $RE2 = $RE_PLAIN_WORDS2;
40550403.66ms50402.16ms if ($self->flowcontext) {
# spent 2.16ms making 5040 calls to YAML::PP::Lexer::flowcontext, avg 428ns/call
406 $RE2 = $RE_PLAIN_WORDS_FLOW2;
407 }
40850401.09ms my $fetch_next = 0;
40950403.28ms my @lines = ($plain);
4105040854µs my @next;
4115040669µs LOOP: while (1) {
41250407.84ms5040119ms $next_line = $self->_fetch_next_line;
# spent 119ms making 5040 calls to YAML::PP::Lexer::_fetch_next_line, avg 24µs/call
4135040821µs if (not $next_line) {
414 last LOOP;
415 }
41650401.67ms my $spaces = $next_line->[0];
41750401.79ms my $yaml = \$next_line->[1];
41850401.41ms my $eol = $next_line->[2];
419
42050401.44ms if (not length $$yaml) {
421 push @tokens, ( EOL => $spaces . $eol, $self->line );
422 $self->set_next_line(undef);
423 push @lines, '';
424 next LOOP;
425 }
426
42750401.57ms631µs if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 29µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 10µs/call # spent 2µs making 3 calls to YAML::PP::Lexer::CORE:subst, avg 667ns/call
428 push @next, $TOKEN_NAMES{ $1 } => $1, $self->line;
429 $fetch_next = 1;
430 last LOOP;
431 }
43250403.85ms if ((length $spaces) < $indent) {
43350404.19ms last LOOP;
434 }
435
436 my $ws = '';
437 if ($$yaml =~ s/\A($RE_WS+)//) {
438 $ws = $1;
439 }
440 if (not length $$yaml) {
441 push @tokens, ( EOL => $spaces . $ws . $eol, $self->line );
442 $self->set_next_line(undef);
443 push @lines, '';
444 next LOOP;
445 }
446 if ($$yaml =~ s/\A(#.*)\z//) {
447 push @tokens, ( EOL => $spaces . $ws . $1 . $eol, $self->line );
448 $self->set_next_line(undef);
449 last LOOP;
450 }
451
452 if ($$yaml =~ s/\A($RE2)//) {
453 push @tokens, INDENT => $spaces, $self->line;
454 push @tokens, WS => $ws, $self->line;
455 push @tokens, PLAIN => $1, $self->line;
456 push @lines, $1;
457 my $ws = '';
458 if ($$yaml =~ s/\A($RE_WS+)//) {
459 $ws = $1;
460 }
461 if (not length $$yaml) {
462 push @tokens, EOL => $ws . $eol, $self->line;
463 $self->set_next_line(undef);
464 next LOOP;
465 }
466
467 if ($$yaml =~ s/\A(#.*)\z//) {
468 push @tokens, EOL => $ws . $1 . $eol, $self->line;
469 $self->set_next_line(undef);
470 last LOOP;
471 }
472 else {
473 push @tokens, WS => $ws, $self->line if $ws;
474 $fetch_next = 1;
475 }
476 }
477 else {
478 push @tokens, SPACE => $spaces, $self->line;
479 push @tokens, WS => $ws, $self->line;
480 if ($self->flowcontext) {
481 $fetch_next = 1;
482 }
483 else {
484 push @tokens, ERROR => $$yaml, $self->line;
485 }
486 }
487
488 last LOOP;
489
490 }
491 # remove empty lines at the end
49250403.28ms while (@lines > 1 and $lines[-1] eq '') {
493 pop @lines;
494 }
49550405.59ms if (@lines > 1) {
496 my $value = YAML::PP::Render->render_multi_val(\@lines);
497 my @eol;
498 if ($tokens[-3] eq 'EOL') {
499 @eol = splice @tokens, -3;
500 }
501 $self->push_subtokens( { name => 'PLAIN_MULTI', value => $value }, \@tokens);
502 $self->_push_tokens([ @eol, @next ]);
503 }
504 else {
50550408.49ms504088.3ms $self->_push_tokens([ @tokens, @next ]);
# spent 88.3ms making 5040 calls to YAML::PP::Lexer::_push_tokens, avg 18µs/call
506 }
50750403.68ms @tokens = ();
50850401.22ms if ($fetch_next) {
509 my $partial = $self->_fetch_next_tokens($next_line);
510 if (not $partial) {
511 $self->set_next_line(undef);
512 }
513 }
514504015.7ms return;
515}
516
517
# spent 423µs (135+288) within YAML::PP::Lexer::fetch_block which was called: # once (135µs+288µs) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm
sub fetch_block {
51811µs my ($self, $indent, $context) = @_;
51911µs10s my $next_line = $self->next_line;
# spent 0s making 1 call to YAML::PP::Lexer::next_line
52011µs my $yaml = \$next_line->[1];
52111µs my $eol = $next_line->[2];
522
52310s my @tokens;
52411µs my $token_name = $TOKEN_NAMES{ $context };
525122µs216µs $$yaml =~ s/\A\Q$context\E// or die "Unexpected";
# spent 13µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 3µs making 1 call to YAML::PP::Lexer::CORE:subst
52612µs11µs push @tokens, ( $token_name => $context, $self->line );
# spent 1µs making 1 call to YAML::PP::Lexer::line
52710s my $current_indent = $indent;
52810s my $started = 0;
52910s my $set_indent = 0;
53010s my $chomp = '';
53119µs22µs if ($$yaml =~ s/\A([1-9])([+-]?)//) {
# spent 2µs making 2 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
532 push @tokens, ( BLOCK_SCALAR_INDENT => $1, $self->line );
533 $set_indent = $1;
534 $chomp = $2 if $2;
535 push @tokens, ( BLOCK_SCALAR_CHOMP => $2, $self->line ) if $2;
536 }
537 elsif ($$yaml =~ s/\A([+-])([1-9])?//) {
53813µs11µs push @tokens, ( BLOCK_SCALAR_CHOMP => $1, $self->line );
# spent 1µs making 1 call to YAML::PP::Lexer::line
53911µs $chomp = $1;
54010s push @tokens, ( BLOCK_SCALAR_INDENT => $2, $self->line ) if $2;
54110s $set_indent = $2 if $2;
542 }
54311µs if ($set_indent) {
544 $started = 1;
545 $indent-- if $indent > 0;
546 $current_indent = $indent + $set_indent;
547 }
54813µs10s if (not length $$yaml) {
# spent 0s making 1 call to YAML::PP::Lexer::line
549 push @tokens, ( EOL => $eol, $self->line );
550 }
551 elsif ($$yaml =~ s/\A($RE_WS*(?:$RE_WS#.*|))\z//) {
552 push @tokens, ( EOL => $1 . $eol, $self->line );
553 }
554 else {
555 $self->_push_tokens(\@tokens);
556 $self->exception("Invalid block scalar");
557 }
558
55910s my @lines;
56010s while (1) {
56164µs64µs $self->set_next_line(undef);
# spent 4µs making 6 calls to YAML::PP::Lexer::set_next_line, avg 667ns/call
56268µs6127µs $next_line = $self->_fetch_next_line;
# spent 127µs making 6 calls to YAML::PP::Lexer::_fetch_next_line, avg 21µs/call
56362µs if (not $next_line) {
564 last;
565 }
56660s my $spaces = $next_line->[0];
56761µs my $content = $next_line->[1];
56862µs my $eol = $next_line->[2];
56961µs if (not $spaces and $content =~ m/\A(---|\.\.\.)(?=$RE_WS|\z)/) {
570 last;
571 }
57263µs if ((length $spaces) < $current_indent) {
57311µs if (length $content) {
57414µs11µs if ($content =~ m/\A\t/) {
# spent 1µs making 1 call to YAML::PP::Lexer::CORE:match
575 $self->_push_tokens(\@tokens);
576 $self->exception("Invalid block scalar");
577 }
57811µs last;
579 }
580 else {
581 push @lines, '';
582 push @tokens, ( EOL => $spaces . $eol, $self->line );
583 next;
584 }
585 }
58651µs if ((length $spaces) > $current_indent) {
58710s if ($started) {
588 ($spaces, my $more_spaces) = unpack "a${current_indent}a*", $spaces;
589 $content = $more_spaces . $content;
590 }
591 }
59251µs unless (length $content) {
593 push @lines, '';
594 push @tokens, ( INDENT => $spaces, $self->line, EOL => $eol, $self->line );
595 unless ($started) {
596 $current_indent = length $spaces;
597 }
598 next;
599 }
60051µs unless ($started) {
60110s $started = 1;
60210s $current_indent = length $spaces;
603 }
60453µs push @lines, $content;
605516µs1510µs push @tokens, (
# spent 10µs making 15 calls to YAML::PP::Lexer::line, avg 667ns/call
606 INDENT => $spaces, $self->line,
607 BLOCK_SCALAR_CONTENT => $content, $self->line,
608 EOL => $eol, $self->line,
609 );
610 }
61116µs119µs my $value = YAML::PP::Render->render_block_scalar($context, $chomp, \@lines);
# spent 19µs making 1 call to YAML::PP::Render::render_block_scalar
61211µs my @eol = splice @tokens, -3;
61312µs191µs $self->push_subtokens( { name => 'BLOCK_SCALAR', value => $value }, \@tokens );
# spent 91µs making 1 call to YAML::PP::Lexer::push_subtokens
61413µs116µs $self->_push_tokens([ @eol ]);
# spent 16µs making 1 call to YAML::PP::Lexer::_push_tokens
61518µs return 0;
616}
617
618
# spent 251ms (66.3+185) within YAML::PP::Lexer::fetch_quoted which was called 2056 times, avg 122µs/call: # 2056 times (66.3ms+185ms) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 122µs/call
sub fetch_quoted {
6192056919µs my ($self, $indent, $context) = @_;
62020562.29ms20561.09ms my $next_line = $self->next_line;
# spent 1.09ms making 2056 calls to YAML::PP::Lexer::next_line, avg 530ns/call
62120561.16ms my $yaml = \$next_line->[1];
6222056965µs my $spaces = $next_line->[0];
623
62420561.04ms my $token_name = $TOKEN_NAMES{ $context };
625205614.4ms41126.43ms $$yaml =~ s/\A\Q$context// or die "Unexpected";;
# spent 4.86ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call # spent 1.57ms making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 766ns/call
62620563.76ms20561.17ms my @tokens = ( $token_name => $context, $self->line );
# spent 1.17ms making 2056 calls to YAML::PP::Lexer::line, avg 568ns/call
627
6282056533µs my $start = 1;
6292056430µs my @values;
6302056427µs while (1) {
631
6322056609µs unless ($start) {
633 $next_line = $self->_fetch_next_line or do {
634 for (my $i = 0; $i < @tokens; $i+= 3) {
635 my $token = $tokens[ $i + 1 ];
636 if (ref $token) {
637 $tokens[ $i + 1 ] = $token->{orig};
638 }
639 }
640 $self->_push_tokens(\@tokens);
641 $self->exception("Missing closing quote <$context> at EOF");
642 };
643 $start = 0;
644 $spaces = $next_line->[0];
645 $yaml = \$next_line->[1];
646
647 if (not length $$yaml) {
648 push @tokens, ( EOL => $spaces . $next_line->[2], $self->line );
649 $self->set_next_line(undef);
650 push @values, { value => '', orig => '' };
651 next;
652 }
653 elsif (not $spaces and $$yaml =~ m/\A(---|\.\.\.)(?=$RE_WS|\z)/) {
654 for (my $i = 0; $i < @tokens; $i+= 3) {
655 my $token = $tokens[ $i + 1 ];
656 if (ref $token) {
657 $tokens[ $i + 1 ] = $token->{orig};
658 }
659 }
660 $self->_push_tokens(\@tokens);
661 $self->exception("Missing closing quote <$context> or invalid document marker");
662 }
663 elsif ((length $spaces) < $indent) {
664 for (my $i = 0; $i < @tokens; $i+= 3) {
665 my $token = $tokens[ $i + 1 ];
666 if (ref $token) {
667 $tokens[ $i + 1 ] = $token->{orig};
668 }
669 }
670 $self->_push_tokens(\@tokens);
671 $self->exception("Wrong indendation or missing closing quote <$context>");
672 }
673
674 if ($$yaml =~ s/\A($RE_WS+)//) {
675 $spaces .= $1;
676 }
677 push @tokens, ( WS => $spaces, $self->line );
678 }
679
68020564.50ms205659.1ms my $v = $self->_read_quoted_tokens($start, $context, $yaml, \@tokens);
# spent 59.1ms making 2056 calls to YAML::PP::Lexer::_read_quoted_tokens, avg 29µs/call
6812056529µs push @values, $v;
68220561.38ms if ($tokens[-3] eq $token_name) {
68320565.92ms205664.0ms if ($start) {
# spent 64.0ms making 2056 calls to YAML::PP::Lexer::push_subtokens, avg 31µs/call
684 $self->push_subtokens(
685 { name => 'QUOTED', value => $v->{value} }, \@tokens
686 );
687 }
688 else {
689 my $value = YAML::PP::Render->render_quoted($context, \@values);
690 $self->push_subtokens(
691 { name => 'QUOTED_MULTILINE', value => $value }, \@tokens
692 );
693 }
69420561.78ms21441.14ms $self->set_context(1) if $self->flowcontext;
# spent 1.02ms making 2056 calls to YAML::PP::Lexer::flowcontext, avg 497ns/call # spent 120µs making 88 calls to YAML::PP::Lexer::set_context, avg 1µs/call
69520561.01ms if (length $$yaml) {
696632726µs63229.6ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 29.6ms making 632 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 47µs/call
697632632µs598435µs if (not $partial) {
# spent 435µs making 598 calls to YAML::PP::Lexer::set_next_line, avg 727ns/call
698 $self->set_next_line(undef);
699 }
7006323.53ms return 0;
701 }
702 else {
70314241.49ms @tokens = ();
70414242.08ms1424694µs push @tokens, ( EOL => $next_line->[2], $self->line );
# spent 694µs making 1424 calls to YAML::PP::Lexer::line, avg 487ns/call
70514241.50ms142419.9ms $self->_push_tokens(\@tokens);
# spent 19.9ms making 1424 calls to YAML::PP::Lexer::_push_tokens, avg 14µs/call
70614241.49ms14241.08ms $self->set_next_line(undef);
# spent 1.08ms making 1424 calls to YAML::PP::Lexer::set_next_line, avg 761ns/call
70714246.81ms return;
708 }
709 }
710 $tokens[-2] .= $next_line->[2];
711 $self->set_next_line(undef);
712 $start = 0;
713 }
714}
715
716
# spent 59.1ms (44.1+14.9) within YAML::PP::Lexer::_read_quoted_tokens which was called 2056 times, avg 29µs/call: # 2056 times (44.1ms+14.9ms) by YAML::PP::Lexer::fetch_quoted at line 680, avg 29µs/call
sub _read_quoted_tokens {
71720561.15ms my ($self, $start, $first, $yaml, $tokens) = @_;
7182056873µs my $quoted = '';
7192056545µs my $decoded = '';
72020561.13ms my $token_name = $TOKEN_NAMES{ $first };
7212056702µs my $eol = '';
72220561.19ms if ($first eq "'") {
72320561.10ms my $regex = $REGEXES{SINGLEQUOTED};
724205615.2ms41127.91ms if ($$yaml =~ s/\A($regex)//) {
# spent 5.15ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 3µs/call # spent 2.76ms making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/call
72520562.69ms $quoted .= $1;
72620561.15ms $decoded .= $1;
72720564.30ms20561.56ms $decoded =~ s/''/'/g;
# spent 1.56ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 761ns/call
728 }
72920561.46ms unless (length $$yaml) {
730 if ($quoted =~ s/($RE_WS+)\z//) {
731 $eol = $1;
732 $decoded =~ s/($eol)\z//;
733 }
734 }
735 }
736 else {
737 ($quoted, $decoded, $eol) = $self->_read_doublequoted($yaml);
738 }
73920563.51ms my $value = { value => $decoded, orig => $quoted };
740
74120568.65ms41123.27ms if ($$yaml =~ s/\A$first//) {
# spent 2.29ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 981µs making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 477ns/call
74220563.45ms20561.29ms if ($start) {
# spent 1.29ms making 2056 calls to YAML::PP::Lexer::line, avg 629ns/call
743 push @$tokens, ( $token_name . 'D' => $value, $self->line );
744 }
745 else {
746 push @$tokens, ( $token_name . 'D_LINE' => $value, $self->line );
747 }
74820562.45ms2056893µs push @$tokens, ( $token_name => $first, $self->line );
# spent 893µs making 2056 calls to YAML::PP::Lexer::line, avg 434ns/call
74920565.26ms return $value;
750 }
751 if (length $$yaml) {
752 push @$tokens, ( $token_name . 'D' => $value->{orig}, $self->line );
753 $self->_push_tokens($tokens);
754 $self->exception("Invalid quoted <$first> string");
755 }
756
757 push @$tokens, ( $token_name . 'D_LINE' => $value, $self->line );
758 push @$tokens, ( EOL => $eol, $self->line );
759
760 return $value;
761}
762
763sub _read_doublequoted {
764 my ($self, $yaml) = @_;
765 my $quoted = '';
766 my $decoded = '';
767 my $eol = '';
768 while (1) {
769 my $last = 1;
770 if ($$yaml =~ s/\A([^"\\ \t]+)//) {
771 $quoted .= $1;
772 $decoded .= $1;
773 $last = 0;
774 }
775 if ($$yaml =~ s/\A($RE_ESCAPES)//) {
776 $quoted .= $1;
777 my $dec = defined $2 ? $CONTROL{ $2 }
778 : defined $3 ? chr hex $3
779 : defined $4 ? chr hex $4
780 : chr hex $5;
781 $decoded .= $dec;
782 $last = 0;
783 }
784 if ($$yaml =~ s/\A([ \t]+)//) {
785 my $spaces = $1;
786 if (length $$yaml) {
787 $quoted .= $spaces;
788 $decoded .= $spaces;
789 $last = 0;
790 }
791 else {
792 $eol = $spaces;
793 last;
794 }
795 }
796 if ($$yaml =~ s/\A(\\)\z//) {
797 $quoted .= $1;
798 $decoded .= $1;
799 last;
800 }
801 last if $last;
802 }
803 return ($quoted, $decoded, $eol);
804}
805
806sub _fetch_next_tokens_directive {
807 my ($self, $yaml, $eol) = @_;
808 my @tokens;
809
810 my $trailing_ws = '';
811 my $warn = $ENV{YAML_PP_RESERVED_DIRECTIVE} || 'warn';
812 if ($$yaml =~ s/\A(\s*%YAML[ \t]+([0-9]+\.[0-9]+))//) {
813 my $dir = $1;
814 my $version = $2;
815 if ($$yaml =~ s/\A($RE_WS+)//) {
816 $trailing_ws = $1;
817 }
818 elsif (length $$yaml) {
819 push @tokens, ( 'Invalid directive' => $dir.$$yaml.$eol, $self->line );
820 $self->_push_tokens(\@tokens);
821 return;
822 }
823 if ($version !~ m/^1\.[12]$/) {
824 if ($warn eq 'warn') {
825 warn "Unsupported YAML version '$dir'";
826 }
827 elsif ($warn eq 'fatal') {
828 push @tokens, ( 'Unsupported YAML version' => $dir, $self->line );
829 $self->_push_tokens(\@tokens);
830 return;
831 }
832 }
833 push @tokens, ( YAML_DIRECTIVE => $dir, $self->line );
834 }
835 elsif ($$yaml =~ s/\A(\s*%TAG[ \t]+(!$RE_NS_WORD_CHAR*!|!)[ \t]+(tag:\S+|!$RE_URI_CHAR+))($RE_WS*)//) {
836 push @tokens, ( TAG_DIRECTIVE => $1, $self->line );
837 # TODO
838 my $tag_alias = $2;
839 my $tag_url = $3;
840 $trailing_ws = $4;
841 }
842 elsif ($$yaml =~ s/\A(\s*\A%(?:\w+).*)//) {
843 push @tokens, ( RESERVED_DIRECTIVE => $1, $self->line );
844 if ($warn eq 'warn') {
845 warn "Found reserved directive '$1'";
846 }
847 elsif ($warn eq 'fatal') {
848 die "Found reserved directive '$1'";
849 }
850 }
851 else {
852 push @tokens, ( 'Invalid directive' => $$yaml, $self->line );
853 push @tokens, ( EOL => $eol, $self->line );
854 $self->_push_tokens(\@tokens);
855 return;
856 }
857 if (not length $$yaml) {
858 push @tokens, ( EOL => $eol, $self->line );
859 }
860 elsif ($trailing_ws and $$yaml =~ s/\A(#.*)?\z//) {
861 push @tokens, ( EOL => "$trailing_ws$1$eol", $self->line );
862 $self->_push_tokens(\@tokens);
863 return;
864 }
865 elsif ($$yaml =~ s/\A([ \t]+#.*)?\z//) {
866 push @tokens, ( EOL => "$1$eol", $self->line );
867 $self->_push_tokens(\@tokens);
868 return;
869 }
870 else {
871 push @tokens, ( 'Invalid directive' => $trailing_ws.$$yaml, $self->line );
872 push @tokens, ( EOL => $eol, $self->line );
873 }
874 $self->_push_tokens(\@tokens);
875 return;
876}
877
878
# spent 889ms (769+120) within YAML::PP::Lexer::_push_tokens which was called 61685 times, avg 14µs/call: # 18884 times (239ms+35.2ms) by YAML::PP::Lexer::_fetch_next_tokens at line 356, avg 15µs/call # 13844 times (153ms+27.6ms) by YAML::PP::Lexer::fetch_plain at line 396, avg 13µs/call # 13449 times (160ms+25.4ms) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 14µs/call # 6456 times (85.4ms+12.7ms) by YAML::PP::Lexer::_fetch_next_tokens at line 304, avg 15µs/call # 5040 times (77.3ms+10.9ms) by YAML::PP::Lexer::fetch_plain at line 505, avg 18µs/call # 2057 times (28.7ms+4.10ms) by YAML::PP::Lexer::_fetch_next_tokens at line 279, avg 16µs/call # 1424 times (17.3ms+2.67ms) by YAML::PP::Lexer::fetch_quoted at line 705, avg 14µs/call # 529 times (9.23ms+1.06ms) by YAML::PP::Lexer::_fetch_next_tokens at line 257, avg 19µs/call # once (29µs+5µs) by YAML::PP::Lexer::fetch_next_tokens at line 208 # once (13µs+3µs) by YAML::PP::Lexer::fetch_block at line 614
sub _push_tokens {
8796168511.5ms my ($self, $new_tokens) = @_;
8806168540.2ms6168530.1ms my $next = $self->next_tokens;
# spent 30.1ms making 61685 calls to YAML::PP::Lexer::next_tokens, avg 488ns/call
8816168536.4ms6168525.8ms my $line = $self->line;
# spent 25.8ms making 61685 calls to YAML::PP::Lexer::line, avg 418ns/call
8826168539.9ms6168527.1ms my $column = $self->offset;
# spent 27.1ms making 61685 calls to YAML::PP::Lexer::offset, avg 440ns/call
883
8846168568.0ms for (my $i = 0; $i < @$new_tokens; $i += 3) {
8859085727.9ms my $value = $new_tokens->[ $i + 1 ];
8869085721.4ms my $name = $new_tokens->[ $i ];
8879085715.9ms my $line = $new_tokens->[ $i + 2 ];
88890857109ms my $push = {
889 name => $name,
890 line => $line,
891 column => $column,
892 value => $value,
893 };
8949085731.2ms $column += length $value unless $name eq 'CONTEXT';
8959085716.1ms push @$next, $push;
8969085734.2ms if ($name eq 'EOL') {
897 $column = 0;
898 }
899 }
9006168543.1ms6168536.6ms $self->set_offset($column);
# spent 36.6ms making 61685 calls to YAML::PP::Lexer::set_offset, avg 594ns/call
90161685104ms return $next;
902}
903
904
# spent 64.1ms (59.7+4.41) within YAML::PP::Lexer::push_subtokens which was called 2057 times, avg 31µs/call: # 2056 times (59.6ms+4.41ms) by YAML::PP::Lexer::fetch_quoted at line 683, avg 31µs/call # once (89µs+2µs) by YAML::PP::Lexer::fetch_block at line 613
sub push_subtokens {
9052057653µs my ($self, $token, $subtokens) = @_;
90620571.61ms20571.12ms my $next = $self->next_tokens;
# spent 1.12ms making 2057 calls to YAML::PP::Lexer::next_tokens, avg 542ns/call
90720571.44ms2057884µs my $line = $self->line;
# spent 884µs making 2057 calls to YAML::PP::Lexer::line, avg 430ns/call
90820571.99ms2057974µs my $column = $self->offset;
# spent 974µs making 2057 calls to YAML::PP::Lexer::offset, avg 474ns/call
90920571.19ms $token->{column} = $column;
91020571.30ms $token->{subtokens} = \my @sub;
911
91220574.90ms for (my $i = 0; $i < @$subtokens; $i+=3) {
91361851.45ms my $name = $subtokens->[ $i ];
91461853.28ms my $value = $subtokens->[ $i + 1 ];
91561851.51ms my $line = $subtokens->[ $i + 2 ];
91661857.58ms my $push = {
917 name => $subtokens->[ $i ],
918 line => $line,
919 column => $column,
920 };
92161853.19ms if (ref $value eq 'HASH') {
92220567.68ms %$push = ( %$push, %$value );
92320561.60ms $column += length $value->{orig};
924 }
925 else {
92641292.38ms $push->{value} = $value;
9274129870µs $column += length $value;
928 }
92961851.59ms if ($push->{name} eq 'EOL') {
930 $column = 0;
931 }
93261852.34ms push @sub, $push;
933 }
93420571.06ms $token->{line} = $sub[0]->{line};
9352057656µs push @$next, $token;
93620571.60ms20571.43ms $self->set_offset($column);
# spent 1.43ms making 2057 calls to YAML::PP::Lexer::set_offset, avg 697ns/call
93720574.32ms return $next;
938}
939
940sub exception {
941 my ($self, $msg) = @_;
942 my $next = $self->next_tokens;
943 $next = [];
944 my $line = @$next ? $next->[0]->{line} : $self->line;
945 my @caller = caller(0);
946 my $yaml = '';
947 if (my $nl = $self->next_line) {
948 $yaml = join '', @$nl;
949 $yaml = $nl->[1];
950 }
951 my $e = YAML::PP::Exception->new(
952 line => $line,
953 column => $self->offset + 1,
954 msg => $msg,
955 next => $next,
956 where => $caller[1] . ' line ' . $caller[2],
957 yaml => $yaml,
958 );
959 croak $e;
960}
961
962156µs1;
 
# spent 24.7ms within YAML::PP::Lexer::CORE:match which was called 13456 times, avg 2µs/call: # 13455 times (24.7ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 148, avg 2µs/call # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 574
sub YAML::PP::Lexer::CORE:match; # opcode
# spent 11µs within YAML::PP::Lexer::CORE:qr which was called 11 times, avg 1µs/call: # 4 times (5µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 1µs/call # once (2µs+0s) by YAML::PP::Parser::BEGIN@18 at line 50 # once (1µs+0s) by YAML::PP::Parser::BEGIN@18 at line 51 # once (1µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # once (1µs+0s) by YAML::PP::Parser::BEGIN@18 at line 121 # once (1µs+0s) by YAML::PP::Parser::BEGIN@18 at line 234 # once (0s+0s) by YAML::PP::Parser::BEGIN@18 at line 122 # once (0s+0s) by YAML::PP::Parser::BEGIN@18 at line 120
sub YAML::PP::Lexer::CORE:qr; # opcode
# spent 201ms within YAML::PP::Lexer::CORE:regcomp which was called 58874 times, avg 3µs/call: # 18884 times (138ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 7µs/call # 18884 times (18.0ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 954ns/call # 14054 times (38.4ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 3µs/call # 2056 times (2.76ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 1µs/call # 2056 times (1.57ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 766ns/call # 2056 times (981µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 477ns/call # 689 times (516µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 749ns/call # 88 times (119µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 1µs/call # 88 times (105µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 270, avg 1µs/call # 6 times (49µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 8µs/call # 3 times (256µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 85µs/call # 3 times (29µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 10µs/call # once (22µs+0s) by YAML::PP::Parser::BEGIN@18 at line 50 # once (13µs+0s) by YAML::PP::Lexer::fetch_block at line 525 # once (13µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # once (9µs+0s) by YAML::PP::Parser::BEGIN@18 at line 121 # once (9µs+0s) by YAML::PP::Parser::BEGIN@18 at line 120 # once (9µs+0s) by YAML::PP::Parser::BEGIN@18 at line 51 # once (8µs+0s) by YAML::PP::Parser::BEGIN@18 at line 122
sub YAML::PP::Lexer::CORE:regcomp; # opcode
# spent 181ms within YAML::PP::Lexer::CORE:subst which was called 75666 times, avg 2µs/call: # 18884 times (100ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 5µs/call # 18884 times (23.9ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 1µs/call # 14054 times (24.8ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 2µs/call # 14054 times (16.1ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 302, avg 1µs/call # 2056 times (5.15ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 3µs/call # 2056 times (4.86ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 2µs/call # 2056 times (2.29ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 1µs/call # 2056 times (1.56ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 727, avg 761ns/call # 689 times (965µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 1µs/call # 689 times (684µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 331, avg 993ns/call # 88 times (52µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 591ns/call # 88 times (31µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 270, avg 352ns/call # 6 times (7µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 1µs/call # 3 times (2µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 667ns/call # 2 times (2µs+0s) by YAML::PP::Lexer::fetch_block at line 531, avg 1µs/call # once (3µs+0s) by YAML::PP::Lexer::fetch_block at line 525
sub YAML::PP::Lexer::CORE:subst; # opcode
Report produced by the NYTProf 6.12 Perl profiler, developed by Tim Bunce based on work by Adam Kaplan and Salvador Fandiño García.