← Index
NYTProf Performance Profile   « line view »
For ../prof.pl
  Run on Thu Dec 15 15:23:56 2022
Reported on Thu Dec 15 15:27:04 2022

Filename/Users/ether/.perlbrew/libs/36.0@std/lib/perl5/YAML/PP/Lexer.pm
StatementsExecuted 3180679 statements in 2.45s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
61194101585ms682msYAML::PP::Lexer::::_push_tokens YAML::PP::Lexer::_push_tokens
2770731397ms827msYAML::PP::Lexer::::_fetch_next_tokens YAML::PP::Lexer::_fetch_next_tokens
1871811384ms1.49sYAML::PP::Lexer::::fetch_plain YAML::PP::Lexer::fetch_plain
1836031175ms295msYAML::PP::Lexer::::_fetch_next_line YAML::PP::Lexer::_fetch_next_line
1335611168ms785msYAML::PP::Lexer::::fetch_next_tokens YAML::PP::Lexer::fetch_next_tokens
58385191154ms154msYAML::PP::Lexer::::CORE:regcomp YAML::PP::Lexer::CORE:regcomp (opcode)
75042161148ms148msYAML::PP::Lexer::::CORE:subst YAML::PP::Lexer::CORE:subst (opcode)
15949222159.9ms59.9msYAML::PP::Lexer::::line YAML::PP::Lexer::line
20451150.4ms198msYAML::PP::Lexer::::fetch_quoted YAML::PP::Lexer::fetch_quoted
20462148.4ms52.5msYAML::PP::Lexer::::push_subtokens YAML::PP::Lexer::push_subtokens
20451135.4ms47.2msYAML::PP::Lexer::::_read_quoted_tokens YAML::PP::Lexer::_read_quoted_tokens
765974232.4ms32.4msYAML::PP::Lexer::::next_tokens YAML::PP::Lexer::next_tokens
632402131.1ms31.1msYAML::PP::Lexer::::set_offset YAML::PP::Lexer::set_offset
755887230.1ms30.1msYAML::PP::Lexer::::flowcontext YAML::PP::Lexer::flowcontext
632402121.8ms21.8msYAML::PP::Lexer::::offset YAML::PP::Lexer::offset
133612119.3ms19.3msYAML::PP::Lexer::::CORE:match YAML::PP::Lexer::CORE:match (opcode)
391244117.6ms17.6msYAML::PP::Lexer::::next_line YAML::PP::Lexer::next_line
371391115.7ms15.7msYAML::PP::Lexer::::context YAML::PP::Lexer::context
267218113.9ms13.9msYAML::PP::Lexer::::set_next_line YAML::PP::Lexer::set_next_line
13360118.25ms8.25msYAML::PP::Lexer::::set_block YAML::PP::Lexer::set_block
13361117.02ms7.02msYAML::PP::Lexer::::reader YAML::PP::Lexer::reader
13924116.82ms6.82msYAML::PP::Lexer::::block YAML::PP::Lexer::block
13360116.09ms6.09msYAML::PP::Lexer::::inc_line YAML::PP::Lexer::inc_line
1112.69ms2.93msYAML::PP::Lexer::::BEGIN@10 YAML::PP::Lexer::BEGIN@10
109011741µs741µsYAML::PP::Lexer::::set_flowcontext YAML::PP::Lexer::set_flowcontext
11194µs272µsYAML::PP::Lexer::::fetch_block YAML::PP::Lexer::fetch_block
1762185µs85µsYAML::PP::Lexer::::set_context YAML::PP::Lexer::set_context
11136µs41µsYAML::PP::Parser::::BEGIN@1YAML::PP::Parser::BEGIN@1
118129µs29µsYAML::PP::Lexer::::CORE:qr YAML::PP::Lexer::CORE:qr (opcode)
1119µs27µsYAML::PP::Lexer::::BEGIN@11 YAML::PP::Lexer::BEGIN@11
1119µs44µsYAML::PP::Parser::::BEGIN@2.286YAML::PP::Parser::BEGIN@2.286
3328µs8µsYAML::PP::Lexer::::init YAML::PP::Lexer::init
1116µs12µsYAML::PP::Lexer::::new YAML::PP::Lexer::new
1115µs46µsYAML::PP::Lexer::::BEGIN@7 YAML::PP::Lexer::BEGIN@7
1114µs4µsYAML::PP::Lexer::::set_reader YAML::PP::Lexer::set_reader
1113µs18µsYAML::PP::Lexer::::BEGIN@8 YAML::PP::Lexer::BEGIN@8
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
1242µs246µs
# spent 41µs (36+5) within YAML::PP::Parser::BEGIN@1 which was called: # once (36µs+5µs) by YAML::PP::Parser::BEGIN@18 at line 1
use strict;
# spent 41µs making 1 call to YAML::PP::Parser::BEGIN@1 # spent 5µs making 1 call to strict::import
2251µs279µs
# spent 44µs (9+35) within YAML::PP::Parser::BEGIN@2.286 which was called: # once (9µs+35µs) by YAML::PP::Parser::BEGIN@18 at line 2
use warnings;
# spent 44µs making 1 call to YAML::PP::Parser::BEGIN@2.286 # spent 35µs making 1 call to warnings::import
3package YAML::PP::Lexer;
4
511µsour $VERSION = '0.035'; # VERSION
6
7225µs287µs
# spent 46µs (5+41) within YAML::PP::Lexer::BEGIN@7 which was called: # once (5µs+41µs) by YAML::PP::Parser::BEGIN@18 at line 7
use constant TRACE => $ENV{YAML_PP_TRACE} ? 1 : 0;
# spent 46µs making 1 call to YAML::PP::Lexer::BEGIN@7 # spent 41µs making 1 call to constant::import
8216µs233µs
# spent 18µs (3+15) within YAML::PP::Lexer::BEGIN@8 which was called: # once (3µs+15µs) by YAML::PP::Parser::BEGIN@18 at line 8
use constant DEBUG => ($ENV{YAML_PP_DEBUG} || $ENV{YAML_PP_TRACE}) ? 1 : 0;
# spent 18µs making 1 call to YAML::PP::Lexer::BEGIN@8 # spent 15µs making 1 call to constant::import
9
102545µs23.05ms
# spent 2.93ms (2.69+235µs) within YAML::PP::Lexer::BEGIN@10 which was called: # once (2.69ms+235µs) by YAML::PP::Parser::BEGIN@18 at line 10
use YAML::PP::Grammar qw/ $GRAMMAR /;
# spent 2.93ms making 1 call to YAML::PP::Lexer::BEGIN@10 # spent 121µs making 1 call to Exporter::import
1124.35ms245µs
# spent 27µs (9+18) within YAML::PP::Lexer::BEGIN@11 which was called: # once (9µs+18µs) by YAML::PP::Parser::BEGIN@18 at line 11
use Carp qw/ croak /;
# spent 27µs making 1 call to YAML::PP::Lexer::BEGIN@11 # spent 18µs making 1 call to Exporter::import
12
13
# spent 12µs (6+6) within YAML::PP::Lexer::new which was called: # once (6µs+6µ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},
1712µs }, $class;
1811µs16µs $self->init;
# spent 6µs making 1 call to YAML::PP::Lexer::init
1912µs return $self;
20}
21
22
# spent 8µs within YAML::PP::Lexer::init which was called 3 times, avg 3µs/call: # once (6µs+0s) by YAML::PP::Lexer::new at line 18 # once (1µs+0s) by YAML::PP::Parser::init at line 115 of YAML/PP/Parser.pm # once (1µs+0s) by YAML::PP::Parser::parse at line 151 of YAML/PP/Parser.pm
sub init {
2331µs my ($self) = @_;
2433µs $self->{next_tokens} = [];
2530s $self->{next_line} = undef;
2631µs $self->{line} = 0;
2731µs $self->{offset} = 0;
2835µs $self->{flowcontext} = 0;
29}
30
313912444.7ms
# spent 17.6ms within YAML::PP::Lexer::next_line which was called 39124 times, avg 449ns/call: # 18718 times (8.69ms+0s) by YAML::PP::Lexer::fetch_plain at line 367, avg 464ns/call # 18360 times (7.85ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 136, avg 427ns/call # 2045 times (1.02ms+0s) by YAML::PP::Lexer::fetch_quoted at line 620, avg 499ns/call # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 519
sub next_line { return $_[0]->{next_line} }
322672132.0ms
# spent 13.9ms within YAML::PP::Lexer::set_next_line which was called 26721 times, avg 520ns/call: # 13360 times (6.27ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 150, avg 469ns/call # 6344 times (3.56ms+0s) by YAML::PP::Lexer::fetch_plain at line 398, avg 561ns/call # 4998 times (2.97ms+0s) by YAML::PP::Lexer::fetch_plain at line 392, avg 594ns/call # 1413 times (765µs+0s) by YAML::PP::Lexer::fetch_quoted at line 706, avg 541ns/call # 598 times (330µs+0s) by YAML::PP::Lexer::fetch_quoted at line 697, avg 552ns/call # 6 times (1µs+0s) by YAML::PP::Lexer::fetch_block at line 561, avg 167ns/call # once (1µs+0s) by YAML::PP::Lexer::_fetch_next_line at line 143 # once (1µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 221
sub set_next_line { $_[0]->{next_line} = $_[1] }
331336114.3ms
# spent 7.02ms within YAML::PP::Lexer::reader which was called 13361 times, avg 525ns/call: # 13361 times (7.02ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 141, avg 525ns/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] }
357659778.7ms
# spent 32.4ms within YAML::PP::Lexer::next_tokens which was called 76597 times, avg 423ns/call: # 61194 times (26.4ms+0s) by YAML::PP::Lexer::_push_tokens at line 880, avg 431ns/call # 13356 times (5.04ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 182, avg 378ns/call # 2046 times (977µs+0s) by YAML::PP::Lexer::push_subtokens at line 906, avg 478ns/call # once (2µs+0s) by YAML::PP::Parser::parse_tokens at line 344 of YAML/PP/Parser.pm
sub next_tokens { return $_[0]->{next_tokens} }
36159492164ms
# spent 59.9ms within YAML::PP::Lexer::line which was called 159492 times, avg 376ns/call: # 61194 times (19.7ms+0s) by YAML::PP::Lexer::_push_tokens at line 881, avg 322ns/call # 18718 times (9.18ms+0s) by YAML::PP::Lexer::fetch_plain at line 381, avg 490ns/call # 18718 times (6.89ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 355, avg 368ns/call # 13953 times (4.75ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 295, avg 340ns/call # 13354 times (5.26ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 394ns/call # 7533 times (3.49ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 307, avg 463ns/call # 6420 times (2.93ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 303, avg 457ns/call # 4998 times (2.12ms+0s) by YAML::PP::Lexer::fetch_plain at line 391, avg 424ns/call # 2046 times (719µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 278, avg 351ns/call # 2046 times (657µs+0s) by YAML::PP::Lexer::push_subtokens at line 907, avg 321ns/call # 2045 times (1.01ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 742, avg 494ns/call # 2045 times (903µs+0s) by YAML::PP::Lexer::fetch_quoted at line 626, avg 442ns/call # 2045 times (663µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 748, avg 324ns/call # 1756 times (561µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 340, avg 319ns/call # 1413 times (564µs+0s) by YAML::PP::Lexer::fetch_quoted at line 704, avg 399ns/call # 666 times (302µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 336, avg 453ns/call # 523 times (208µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 256, avg 398ns/call # 15 times (4µs+0s) by YAML::PP::Lexer::fetch_block at line 605, avg 267ns/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 548 # once (0s+0s) by YAML::PP::Lexer::fetch_block at line 526 # once (0s+0s) by YAML::PP::Lexer::fetch_block at line 538
sub line { return $_[0]->{line} }
37sub set_line { $_[0]->{line} = $_[1] }
386324061.6ms
# spent 21.8ms within YAML::PP::Lexer::offset which was called 63240 times, avg 345ns/call: # 61194 times (20.9ms+0s) by YAML::PP::Lexer::_push_tokens at line 882, avg 341ns/call # 2046 times (935µs+0s) by YAML::PP::Lexer::push_subtokens at line 908, avg 457ns/call
sub offset { return $_[0]->{offset} }
396324075.6ms
# spent 31.1ms within YAML::PP::Lexer::set_offset which was called 63240 times, avg 492ns/call: # 61194 times (29.5ms+0s) by YAML::PP::Lexer::_push_tokens at line 900, avg 483ns/call # 2046 times (1.56ms+0s) by YAML::PP::Lexer::push_subtokens at line 936, avg 761ns/call
sub set_offset { $_[0]->{offset} = $_[1] }
401336014.7ms
# spent 6.09ms within YAML::PP::Lexer::inc_line which was called 13360 times, avg 456ns/call: # 13360 times (6.09ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 147, avg 456ns/call
sub inc_line { return $_[0]->{line}++ }
413713941.2ms
# spent 15.7ms within YAML::PP::Lexer::context which was called 37139 times, avg 424ns/call: # 37139 times (15.7ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 263, avg 424ns/call
sub context { return $_[0]->{context} }
42176182µs
# spent 85µs within YAML::PP::Lexer::set_context which was called 176 times, avg 483ns/call: # 88 times (47µs+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 534ns/call # 88 times (38µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 275, avg 432ns/call
sub set_context { $_[0]->{context} = $_[1] }
437558882.4ms
# spent 30.1ms within YAML::PP::Lexer::flowcontext which was called 75588 times, avg 399ns/call: # 20764 times (7.97ms+0s) by YAML::PP::Parser::parse_tokens at line 379 of YAML/PP/Parser.pm, avg 384ns/call # 18718 times (6.25ms+0s) by YAML::PP::Lexer::fetch_plain at line 371, avg 334ns/call # 13953 times (6.65ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 476ns/call # 13354 times (6.14ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 460ns/call # 4998 times (1.61ms+0s) by YAML::PP::Lexer::fetch_plain at line 405, avg 322ns/call # 2045 times (875µs+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 428ns/call # 1756 times (645µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 342, avg 367ns/call
sub flowcontext { return $_[0]->{flowcontext} }
4410901.45ms
# spent 741µs within YAML::PP::Lexer::set_flowcontext which was called 1090 times, avg 680ns/call: # 1090 times (741µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 343, avg 680ns/call
sub set_flowcontext { $_[0]->{flowcontext} = $_[1] }
451392414.8ms
# spent 6.82ms within YAML::PP::Lexer::block which was called 13924 times, avg 490ns/call: # 13924 times (6.82ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 490ns/call
sub block { return $_[0]->{block} }
461336015.8ms
# spent 8.25ms within YAML::PP::Lexer::set_block which was called 13360 times, avg 618ns/call: # 13360 times (8.25ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 146, avg 618ns/call
sub set_block { $_[0]->{block} = $_[1] }
47
4811µsmy $RE_WS = '[\t ]';
4910smy $RE_LB = '[\r\n]';
50145µs227µsmy $RE_DOC_END = qr/\A(\.\.\.)(?=$RE_WS|$)/m;
# spent 22µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 5µs making 1 call to YAML::PP::Lexer::CORE:qr
51121µs214µsmy $RE_DOC_START = qr/\A(---)(?=$RE_WS|$)/m;
# spent 12µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 2µs making 1 call to YAML::PP::Lexer::CORE:qr
521157µs2144µsmy $RE_EOL = qr/\A($RE_WS+#.*|$RE_WS+)\z/;
# spent 141µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 3µ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 | “-”
5610smy $RE_NS_WORD_CHAR = '[0-9A-Za-z-]';
5710smy $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
7211µsmy $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}]';
7411µsmy $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
9712µsmy $RE_PLAIN_WORD = "(?::+$RE_PLAIN_END|$RE_PLAIN_START)(?::+$RE_PLAIN_END|$RE_PLAIN_END)*";
9810smy $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)*)";
10010smy $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)*";
10311µsmy $RE_PLAIN_FIRST_WORD_FLOW = "(?:[:?-]+$RE_PLAIN_END_FLOW|$RE_PLAIN_FIRST_FLOW)(?::+$RE_PLAIN_END_FLOW|$RE_PLAIN_END_FLOW)*";
10414µsmy $RE_PLAIN_WORDS_FLOW = "(?:$RE_PLAIN_FIRST_WORD_FLOW(?:$RE_WS+$RE_PLAIN_WORD_FLOW)*)";
10510smy $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*
11311µsmy $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
120144µs220µsmy $RE_SEQSTART = qr/\A(-)(?=$RE_WS|$)/m;
# spent 18µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 2µs making 1 call to YAML::PP::Lexer::CORE:qr
121119µs213µsmy $RE_COMPLEX = qr/(\?)(?=$RE_WS|$)/m;
# spent 12µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
122118µs214µsmy $RE_COMPLEXCOLON = qr/\A(:)(?=$RE_WS|$)/m;
# spent 13µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
12310smy $RE_ANCHOR = "&$RE_ANCHOR_CAR+";
12410smy $RE_ALIAS = "\\*$RE_ANCHOR_CAR+";
125
126
1271303µs7251µsmy %REGEXES = (
# spent 237µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 79µs/call # spent 14µs making 4 calls to YAML::PP::Lexer::CORE:qr, avg 4µ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 295ms (175+119) within YAML::PP::Lexer::_fetch_next_line which was called 18360 times, avg 16µs/call: # 13356 times (114ms+83.0ms) by YAML::PP::Lexer::fetch_next_tokens at line 185, avg 15µs/call # 4998 times (61.2ms+36.0ms) by YAML::PP::Lexer::fetch_plain at line 412, avg 19µs/call # 6 times (48µs+35µs) by YAML::PP::Lexer::fetch_block at line 562, avg 14µs/call
sub _fetch_next_line {
135183603.09ms my ($self) = @_;
1361836011.2ms183607.85ms my $next_line = $self->next_line;
# spent 7.85ms making 18360 calls to YAML::PP::Lexer::next_line, avg 427ns/call
137183608.77ms if (defined $next_line ) {
138 return $next_line;
139 }
140
1411336120.5ms2672271.3ms my $line = $self->reader->readline;
# spent 64.3ms making 13361 calls to YAML::PP::Reader::File::readline, avg 5µs/call # spent 7.02ms making 13361 calls to YAML::PP::Lexer::reader, avg 525ns/call
142133612.07ms 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 }
146133609.83ms133608.25ms $self->set_block(1);
# spent 8.25ms making 13360 calls to YAML::PP::Lexer::set_block, avg 618ns/call
147133607.38ms133606.09ms $self->inc_line;
# spent 6.09ms making 13360 calls to YAML::PP::Lexer::inc_line, avg 456ns/call
1481336034.8ms1336019.3ms $line =~ m/\A( *)([^\r\n]*)([\r\n]|\z)/ or die "Unexpected";
# spent 19.3ms making 13360 calls to YAML::PP::Lexer::CORE:match, avg 1µs/call
1491336018.2ms $next_line = [ $1, $2, $3 ];
150133607.83ms133606.27ms $self->set_next_line($next_line);
# spent 6.27ms making 13360 calls to YAML::PP::Lexer::set_next_line, avg 469ns/call
151 # $ESCAPE_CHAR from YAML.pm
152133606.23ms if ($line =~ tr/\x00-\x08\x0b-\x0c\x0e-\x1f//) {
153 $self->exception("Control characters are not allowed");
154 }
155
1561336019.6ms return $next_line;
157}
158
15917µ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 785ms (168+617) within YAML::PP::Lexer::fetch_next_tokens which was called 13356 times, avg 59µs/call: # 13356 times (168ms+617ms) by YAML::PP::Parser::lex_next_tokens at line 179 of YAML/PP/Parser.pm, avg 59µs/call
sub fetch_next_tokens {
181133562.63ms my ($self) = @_;
182133567.59ms133565.04ms my $next = $self->next_tokens;
# spent 5.04ms making 13356 calls to YAML::PP::Lexer::next_tokens, avg 378ns/call
183133562.39ms return $next if @$next;
184
1851335610.6ms13356197ms my $next_line = $self->_fetch_next_line;
# spent 197ms making 13356 calls to YAML::PP::Lexer::_fetch_next_line, avg 15µs/call
186133561.91ms if (not $next_line) {
187 return [];
188 }
189
190133553.81ms my $spaces = $next_line->[0];
191133553.49ms my $yaml = \$next_line->[1];
192133553.27ms if (not length $$yaml) {
193 $self->_push_tokens([ EOL => join('', @$next_line), $self->line ]);
194 $self->set_next_line(undef);
195 return $next;
196 }
1971335510.3ms 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 }
202133551.93ms 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 }
2081335517.4ms133686.21ms if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 6.14ms making 13354 calls to YAML::PP::Lexer::flowcontext, avg 460ns/call # spent 37µs making 6 calls to YAML::PP::Lexer::CORE:regcomp, avg 6µs/call # spent 24µs making 1 call to YAML::PP::Lexer::_push_tokens # spent 6µ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 {
2171335419.9ms26708148ms $self->_push_tokens([ SPACE => $spaces, $self->line ]);
# spent 143ms making 13354 calls to YAML::PP::Lexer::_push_tokens, avg 11µs/call # spent 5.26ms making 13354 calls to YAML::PP::Lexer::line, avg 394ns/call
218 }
219
2201335510.6ms13355261ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 261ms making 13355 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 20µs/call
221133551.55ms11µs unless ($partial) {
# spent 1µs making 1 call to YAML::PP::Lexer::set_next_line
222 $self->set_next_line(undef);
223 }
2241335519.5ms return $next;
225}
226
22711µsmy %ANCHOR_ALIAS_TAG = ( '&' => 1, '*' => 1, '!' => 1 );
22811µsmy %BLOCK_SCALAR = ( '|' => 1, '>' => 1 );
22911µsmy %COLON_DASH_QUESTION = ( ':' => 1, '-' => 1, '?' => 1 );
23011µsmy %QUOTED = ( '"' => 1, "'" => 1 );
23110smy %FLOW = ( '{' => 1, '[' => 1, '}' => 1, ']' => 1, ',' => 1 );
23210smy %CONTEXT = ( '"' => 1, "'" => 1, '>' => 1, '|' => 1 );
233
23413µ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;
23818µ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 827ms (397+429) within YAML::PP::Lexer::_fetch_next_tokens which was called 27707 times, avg 30µs/call: # 13720 times (276ms+266ms) by YAML::PP::Lexer::fetch_plain at line 397, avg 39µs/call # 13355 times (110ms+151ms) by YAML::PP::Lexer::fetch_next_tokens at line 220, avg 20µs/call # 632 times (11.6ms+12.2ms) by YAML::PP::Lexer::fetch_quoted at line 696, avg 38µs/call
sub _fetch_next_tokens {
246 TRACE and warn __PACKAGE__.':'.__LINE__.": _fetch_next_tokens\n";
247277074.78ms my ($self, $next_line) = @_;
248
249277076.59ms my $yaml = \$next_line->[1];
250277075.04ms my $eol = $next_line->[2];
251
252277072.68ms my @tokens;
253
254277073.19ms while (1) {
255376625.43ms unless (length $$yaml) {
256523487µs523208µs push @tokens, ( EOL => $eol, $self->line );
# spent 208µs making 523 calls to YAML::PP::Lexer::line, avg 398ns/call
257523412µs5237.65ms $self->_push_tokens(\@tokens);
# spent 7.65ms making 523 calls to YAML::PP::Lexer::_push_tokens, avg 15µs/call
2585231.03ms return;
259 }
2603713913.1ms my $first = substr($$yaml, 0, 1);
261371394.24ms my $plain = 0;
262
2633713921.2ms3713915.7ms if ($self->context) {
# spent 15.7ms making 37139 calls to YAML::PP::Lexer::context, avg 424ns/call
26488238µs17693µs if ($$yaml =~ s/\A($RE_WS*)://) {
# spent 52µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 591ns/call # spent 41µs making 88 calls to YAML::PP::Lexer::CORE:subst, avg 466ns/call
265 push @tokens, ( WS => $1, $self->line ) if $1;
266 push @tokens, ( COLON => ':', $self->line );
267 $self->set_context(0);
268 next;
269 }
27088258µs17691µs if ($$yaml =~ s/\A($RE_WS*(?: #.*))\z//) {
# spent 65µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 739ns/call # spent 26µs making 88 calls to YAML::PP::Lexer::CORE:subst, avg 295ns/call
271 push @tokens, ( EOL => $1 . $eol, $self->line );
272 $self->_push_tokens(\@tokens);
273 return;
274 }
2758878µs8838µs $self->set_context(0);
# spent 38µs making 88 calls to YAML::PP::Lexer::set_context, avg 432ns/call
276 }
2773713924.2ms if ($CONTEXT{ $first }) {
27820462.37ms2046719µs push @tokens, ( CONTEXT => $first, $self->line );
# spent 719µs making 2046 calls to YAML::PP::Lexer::line, avg 351ns/call
27920461.40ms204626.0ms $self->_push_tokens(\@tokens);
# spent 26.0ms making 2046 calls to YAML::PP::Lexer::_push_tokens, avg 13µs/call
28020463.80ms return 1;
281 }
282 elsif ($COLON_DASH_QUESTION{ $first }) {
283139534.37ms my $token_name = $TOKEN_NAMES{ $first };
2841395384.1ms2790649.8ms if ($$yaml =~ s/\A\Q$first\E($RE_WS+|\z)//) {
# spent 29.8ms making 13953 calls to YAML::PP::Lexer::CORE:regcomp, avg 2µs/call # spent 20.0ms making 13953 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
285139534.49ms my $after = $1;
2861395317.1ms2787713.5ms if (not $self->flowcontext and not $self->block) {
# spent 6.82ms making 13924 calls to YAML::PP::Lexer::block, avg 490ns/call # spent 6.65ms making 13953 calls to YAML::PP::Lexer::flowcontext, avg 476ns/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 }
291139534.20ms if ($after =~ tr/\t//) {
292 $self->set_block(0);
293 }
294139533.22ms my $token_name = $TOKEN_NAMES{ $first };
2951395312.2ms139534.75ms push @tokens, ( $token_name => $first, $self->line );
# spent 4.75ms making 13953 calls to YAML::PP::Lexer::line, avg 340ns/call
296139533.01ms if (not defined $1) {
297 push @tokens, ( EOL => $eol, $self->line );
298 $self->_push_tokens(\@tokens);
299 return;
300 }
301139532.64ms my $ws = $1;
3021395329.1ms1395313.5ms if ($$yaml =~ s/\A(#.*|)\z//) {
# spent 13.5ms making 13953 calls to YAML::PP::Lexer::CORE:subst, avg 969ns/call
30364209.71ms64202.93ms push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
# spent 2.93ms making 6420 calls to YAML::PP::Lexer::line, avg 457ns/call
30464203.80ms642079.1ms $self->_push_tokens(\@tokens);
# spent 79.1ms making 6420 calls to YAML::PP::Lexer::_push_tokens, avg 12µs/call
305642018.8ms return;
306 }
30775337.07ms75333.49ms push @tokens, ( WS => $ws, $self->line );
# spent 3.49ms making 7533 calls to YAML::PP::Lexer::line, avg 463ns/call
30875336.55ms 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") {
3296662.75ms13321.14ms if ($$yaml =~ s/\A($RE_WS+)//) {
# spent 753µs making 666 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 386µs making 666 calls to YAML::PP::Lexer::CORE:regcomp, avg 580ns/call
330666293µs my $ws = $1;
3316661.28ms666595µs if ($$yaml =~ s/\A((?:#.*)?\z)//) {
# spent 595µs making 666 calls to YAML::PP::Lexer::CORE:subst, avg 893ns/call
332 push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
333 $self->_push_tokens(\@tokens);
334 return;
335 }
336666658µs666302µs push @tokens, ( WS => $ws, $self->line );
# spent 302µs making 666 calls to YAML::PP::Lexer::line, avg 453ns/call
337 }
338 }
339 elsif ($FLOW{ $first }) {
34017562.05ms1756561µs push @tokens, ( $TOKEN_NAMES{ $first } => $first, $self->line );
# spent 561µs making 1756 calls to YAML::PP::Lexer::line, avg 319ns/call
34117561.37ms substr($$yaml, 0, 1, '');
34217561.04ms1756645µs my $flowcontext = $self->flowcontext;
# spent 645µs making 1756 calls to YAML::PP::Lexer::flowcontext, avg 367ns/call
34317561.53ms1090741µs if ($first eq '{' or $first eq '[') {
# spent 741µs making 1090 calls to YAML::PP::Lexer::set_flowcontext, avg 680ns/call
344 $self->set_flowcontext(++$flowcontext);
345 }
346 elsif ($first eq '}' or $first eq ']') {
347 $self->set_flowcontext(--$flowcontext);
348 }
349 }
350 else {
351187182.50ms $plain = 1;
352 }
353
354211403.04ms if ($plain) {
3551871813.8ms187186.89ms push @tokens, ( CONTEXT => '', $self->line );
# spent 6.89ms making 18718 calls to YAML::PP::Lexer::line, avg 368ns/call
3561871810.9ms18718201ms $self->_push_tokens(\@tokens);
# spent 201ms making 18718 calls to YAML::PP::Lexer::_push_tokens, avg 11µs/call
3571871831.9ms return 1;
358 }
359
360 }
361
362 return;
363}
364
365
# spent 1.49s (384ms+1.11) within YAML::PP::Lexer::fetch_plain which was called 18718 times, avg 80µs/call: # 18718 times (384ms+1.11s) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 80µs/call
sub fetch_plain {
366187185.11ms my ($self, $indent, $context) = @_;
3671871812.5ms187188.69ms my $next_line = $self->next_line;
# spent 8.69ms making 18718 calls to YAML::PP::Lexer::next_line, avg 464ns/call
368187184.46ms my $yaml = \$next_line->[1];
369187183.41ms my $eol = $next_line->[2];
370187183.53ms my $REGEX = $RE_PLAIN_WORDS;
371187189.21ms187186.25ms if ($self->flowcontext) {
# spent 6.25ms making 18718 calls to YAML::PP::Lexer::flowcontext, avg 334ns/call
372 $REGEX = $RE_PLAIN_WORDS_FLOW;
373 }
374
375187182.06ms my @tokens;
37618718262ms37436188ms unless ($$yaml =~ s/\A($REGEX)//) {
# spent 105ms making 18718 calls to YAML::PP::Lexer::CORE:regcomp, avg 6µs/call # spent 82.7ms making 18718 calls to YAML::PP::Lexer::CORE:subst, avg 4µs/call
377 $self->_push_tokens(\@tokens);
378 $self->exception("Invalid plain scalar");
379 }
380187189.46ms my $plain = $1;
3811871818.1ms187189.18ms push @tokens, ( PLAIN => $plain, $self->line );
# spent 9.18ms making 18718 calls to YAML::PP::Lexer::line, avg 490ns/call
382
3831871873.2ms3743633.0ms if ($$yaml =~ s/\A(?:($RE_WS+#.*)|($RE_WS*))\z//) {
# spent 19.0ms making 18718 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 14.0ms making 18718 calls to YAML::PP::Lexer::CORE:regcomp, avg 746ns/call
38449982.19ms 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 {
39149986.44ms49982.12ms push @tokens, ( EOL => $2. $eol, $self->line );
# spent 2.12ms making 4998 calls to YAML::PP::Lexer::line, avg 424ns/call
39249984.00ms49982.97ms $self->set_next_line(undef);
# spent 2.97ms making 4998 calls to YAML::PP::Lexer::set_next_line, avg 594ns/call
393 }
394 }
395 else {
396137209.04ms13720142ms $self->_push_tokens(\@tokens);
# spent 142ms making 13720 calls to YAML::PP::Lexer::_push_tokens, avg 10µs/call
3971372018.7ms13720542ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 542ms making 13720 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 39µs/call
398137205.45ms63443.56ms if (not $partial) {
# spent 3.56ms making 6344 calls to YAML::PP::Lexer::set_next_line, avg 561ns/call
399 $self->set_next_line(undef);
400 }
4011372032.4ms return;
402 }
403
40449981.14ms my $RE2 = $RE_PLAIN_WORDS2;
40549982.96ms49981.61ms if ($self->flowcontext) {
# spent 1.61ms making 4998 calls to YAML::PP::Lexer::flowcontext, avg 322ns/call
406 $RE2 = $RE_PLAIN_WORDS_FLOW2;
407 }
4084998599µs my $fetch_next = 0;
40949982.31ms my @lines = ($plain);
4104998580µs my @next;
4114998725µs LOOP: while (1) {
41249986.74ms499897.2ms $next_line = $self->_fetch_next_line;
# spent 97.2ms making 4998 calls to YAML::PP::Lexer::_fetch_next_line, avg 19µs/call
4134998869µs if (not $next_line) {
414 last LOOP;
415 }
41649981.39ms my $spaces = $next_line->[0];
41749981.35ms my $yaml = \$next_line->[1];
41849981.12ms my $eol = $next_line->[2];
419
42049981.17ms 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
42749981.13ms620µs if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 17µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 6µs/call # spent 3µs making 3 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
428 push @next, $TOKEN_NAMES{ $1 } => $1, $self->line;
429 $fetch_next = 1;
430 last LOOP;
431 }
43249982.91ms if ((length $spaces) < $indent) {
43349983.61ms 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
49249982.64ms while (@lines > 1 and $lines[-1] eq '') {
493 pop @lines;
494 }
49549984.58ms 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 {
50549987.29ms499869.6ms $self->_push_tokens([ @tokens, @next ]);
# spent 69.6ms making 4998 calls to YAML::PP::Lexer::_push_tokens, avg 14µs/call
506 }
50749982.71ms @tokens = ();
5084998897µs if ($fetch_next) {
509 my $partial = $self->_fetch_next_tokens($next_line);
510 if (not $partial) {
511 $self->set_next_line(undef);
512 }
513 }
514499812.2ms return;
515}
516
517
# spent 272µs (94+178) within YAML::PP::Lexer::fetch_block which was called: # once (94µs+178µs) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm
sub fetch_block {
51811µs my ($self, $indent, $context) = @_;
51912µs11µs my $next_line = $self->next_line;
# spent 1µs making 1 call to YAML::PP::Lexer::next_line
52010s my $yaml = \$next_line->[1];
52110s my $eol = $next_line->[2];
522
52310s my @tokens;
52411µs my $token_name = $TOKEN_NAMES{ $context };
525111µs26µs $$yaml =~ s/\A\Q$context\E// or die "Unexpected";
# spent 5µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:subst
52611µs10s push @tokens, ( $token_name => $context, $self->line );
# spent 0s making 1 call to YAML::PP::Lexer::line
52710s my $current_indent = $indent;
52810s my $started = 0;
52910s my $set_indent = 0;
53011µs my $chomp = '';
53114µs23µs if ($$yaml =~ s/\A([1-9])([+-]?)//) {
# spent 3µs making 2 calls to YAML::PP::Lexer::CORE:subst, avg 2µ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])?//) {
53811µs10s push @tokens, ( BLOCK_SCALAR_CHOMP => $1, $self->line );
# spent 0s making 1 call to YAML::PP::Lexer::line
53911µs $chomp = $1;
54010s push @tokens, ( BLOCK_SCALAR_INDENT => $2, $self->line ) if $2;
54111µs $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 }
54812µs11µs if (not length $$yaml) {
# spent 1µs 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;
56011µs while (1) {
56162µs61µs $self->set_next_line(undef);
# spent 1µs making 6 calls to YAML::PP::Lexer::set_next_line, avg 167ns/call
56263µs683µs $next_line = $self->_fetch_next_line;
# spent 83µs making 6 calls to YAML::PP::Lexer::_fetch_next_line, avg 14µs/call
56361µs if (not $next_line) {
564 last;
565 }
56662µs my $spaces = $next_line->[0];
56760s my $content = $next_line->[1];
56861µs my $eol = $next_line->[2];
56961µs if (not $spaces and $content =~ m/\A(---|\.\.\.)(?=$RE_WS|\z)/) {
570 last;
571 }
57262µs if ((length $spaces) < $current_indent) {
57310s if (length $content) {
57413µ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 }
57810s 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) {
58711µs if ($started) {
588 ($spaces, my $more_spaces) = unpack "a${current_indent}a*", $spaces;
589 $content = $more_spaces . $content;
590 }
591 }
59250s 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 }
60050s unless ($started) {
60110s $started = 1;
60211µs $current_indent = length $spaces;
603 }
60451µs push @lines, $content;
605517µs154µs push @tokens, (
# spent 4µs making 15 calls to YAML::PP::Lexer::line, avg 267ns/call
606 INDENT => $spaces, $self->line,
607 BLOCK_SCALAR_CONTENT => $content, $self->line,
608 EOL => $eol, $self->line,
609 );
610 }
61118µs116µs my $value = YAML::PP::Render->render_block_scalar($context, $chomp, \@lines);
# spent 16µs making 1 call to YAML::PP::Render::render_block_scalar
61211µs my @eol = splice @tokens, -3;
61311µs154µs $self->push_subtokens( { name => 'BLOCK_SCALAR', value => $value }, \@tokens );
# spent 54µs making 1 call to YAML::PP::Lexer::push_subtokens
61412µs18µs $self->_push_tokens([ @eol ]);
# spent 8µs making 1 call to YAML::PP::Lexer::_push_tokens
61515µs return 0;
616}
617
618
# spent 198ms (50.4+147) within YAML::PP::Lexer::fetch_quoted which was called 2045 times, avg 97µs/call: # 2045 times (50.4ms+147ms) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 97µs/call
sub fetch_quoted {
6192045856µs my ($self, $indent, $context) = @_;
62020451.75ms20451.02ms my $next_line = $self->next_line;
# spent 1.02ms making 2045 calls to YAML::PP::Lexer::next_line, avg 499ns/call
6212045845µs my $yaml = \$next_line->[1];
6222045678µs my $spaces = $next_line->[0];
623
6242045597µs my $token_name = $TOKEN_NAMES{ $context };
625204510.6ms40905.12ms $$yaml =~ s/\A\Q$context// or die "Unexpected";;
# spent 3.99ms making 2045 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call # spent 1.13ms making 2045 calls to YAML::PP::Lexer::CORE:regcomp, avg 551ns/call
62620453.06ms2045903µs my @tokens = ( $token_name => $context, $self->line );
# spent 903µs making 2045 calls to YAML::PP::Lexer::line, avg 442ns/call
627
6282045484µs my $start = 1;
6292045351µs my @values;
6302045318µs while (1) {
631
6322045305µ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
68020453.51ms204547.2ms my $v = $self->_read_quoted_tokens($start, $context, $yaml, \@tokens);
# spent 47.2ms making 2045 calls to YAML::PP::Lexer::_read_quoted_tokens, avg 23µs/call
6812045470µs push @values, $v;
6822045983µs if ($tokens[-3] eq $token_name) {
68320455.07ms204552.5ms if ($start) {
# spent 52.5ms making 2045 calls to YAML::PP::Lexer::push_subtokens, avg 26µ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 }
69420451.61ms2133922µs $self->set_context(1) if $self->flowcontext;
# spent 875µs making 2045 calls to YAML::PP::Lexer::flowcontext, avg 428ns/call # spent 47µs making 88 calls to YAML::PP::Lexer::set_context, avg 534ns/call
69520451.06ms if (length $$yaml) {
696632595µs63223.8ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 23.8ms making 632 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 38µs/call
697632586µs598330µs if (not $partial) {
# spent 330µs making 598 calls to YAML::PP::Lexer::set_next_line, avg 552ns/call
698 $self->set_next_line(undef);
699 }
7006322.70ms return 0;
701 }
702 else {
70314131.01ms @tokens = ();
70414131.71ms1413564µs push @tokens, ( EOL => $next_line->[2], $self->line );
# spent 564µs making 1413 calls to YAML::PP::Lexer::line, avg 399ns/call
7051413985µs141314.1ms $self->_push_tokens(\@tokens);
# spent 14.1ms making 1413 calls to YAML::PP::Lexer::_push_tokens, avg 10µs/call
7061413945µs1413765µs $self->set_next_line(undef);
# spent 765µs making 1413 calls to YAML::PP::Lexer::set_next_line, avg 541ns/call
70714135.28ms return;
708 }
709 }
710 $tokens[-2] .= $next_line->[2];
711 $self->set_next_line(undef);
712 $start = 0;
713 }
714}
715
716
# spent 47.2ms (35.4+11.8) within YAML::PP::Lexer::_read_quoted_tokens which was called 2045 times, avg 23µs/call: # 2045 times (35.4ms+11.8ms) by YAML::PP::Lexer::fetch_quoted at line 680, avg 23µs/call
sub _read_quoted_tokens {
7172045959µs my ($self, $start, $first, $yaml, $tokens) = @_;
7182045712µs my $quoted = '';
7192045610µs my $decoded = '';
7202045674µs my $token_name = $TOKEN_NAMES{ $first };
7212045447µs my $eol = '';
72220451.08ms if ($first eq "'") {
7232045832µs my $regex = $REGEXES{SINGLEQUOTED};
724204512.0ms40905.98ms if ($$yaml =~ s/\A($regex)//) {
# spent 4.16ms making 2045 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call # spent 1.82ms making 2045 calls to YAML::PP::Lexer::CORE:regcomp, avg 890ns/call
72520452.12ms $quoted .= $1;
7262045837µs $decoded .= $1;
72720453.41ms20451.29ms $decoded =~ s/''/'/g;
# spent 1.29ms making 2045 calls to YAML::PP::Lexer::CORE:subst, avg 632ns/call
728 }
72920451.25ms 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 }
73920452.79ms my $value = { value => $decoded, orig => $quoted };
740
74120457.02ms40902.88ms if ($$yaml =~ s/\A$first//) {
# spent 2.03ms making 2045 calls to YAML::PP::Lexer::CORE:subst, avg 994ns/call # spent 851µs making 2045 calls to YAML::PP::Lexer::CORE:regcomp, avg 416ns/call
74220452.94ms20451.01ms if ($start) {
# spent 1.01ms making 2045 calls to YAML::PP::Lexer::line, avg 494ns/call
743 push @$tokens, ( $token_name . 'D' => $value, $self->line );
744 }
745 else {
746 push @$tokens, ( $token_name . 'D_LINE' => $value, $self->line );
747 }
74820451.92ms2045663µs push @$tokens, ( $token_name => $first, $self->line );
# spent 663µs making 2045 calls to YAML::PP::Lexer::line, avg 324ns/call
74920454.09ms 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 682ms (585+96.5) within YAML::PP::Lexer::_push_tokens which was called 61194 times, avg 11µs/call: # 18718 times (171ms+29.7ms) by YAML::PP::Lexer::_fetch_next_tokens at line 356, avg 11µs/call # 13720 times (120ms+21.7ms) by YAML::PP::Lexer::fetch_plain at line 396, avg 10µs/call # 13354 times (122ms+20.2ms) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 11µs/call # 6420 times (69.3ms+9.75ms) by YAML::PP::Lexer::_fetch_next_tokens at line 304, avg 12µs/call # 4998 times (60.6ms+9.01ms) by YAML::PP::Lexer::fetch_plain at line 505, avg 14µs/call # 2046 times (22.8ms+3.18ms) by YAML::PP::Lexer::_fetch_next_tokens at line 279, avg 13µs/call # 1413 times (12.0ms+2.11ms) by YAML::PP::Lexer::fetch_quoted at line 705, avg 10µs/call # 523 times (6.74ms+908µs) by YAML::PP::Lexer::_fetch_next_tokens at line 257, avg 15µs/call # once (21µs+3µs) by YAML::PP::Lexer::fetch_next_tokens at line 208 # once (6µs+2µs) by YAML::PP::Lexer::fetch_block at line 614
sub _push_tokens {
8796119410.4ms my ($self, $new_tokens) = @_;
8806119434.8ms6119426.4ms my $next = $self->next_tokens;
# spent 26.4ms making 61194 calls to YAML::PP::Lexer::next_tokens, avg 431ns/call
8816119428.6ms6119419.7ms my $line = $self->line;
# spent 19.7ms making 61194 calls to YAML::PP::Lexer::line, avg 322ns/call
8826119430.4ms6119420.9ms my $column = $self->offset;
# spent 20.9ms making 61194 calls to YAML::PP::Lexer::offset, avg 341ns/call
883
8846119456.4ms for (my $i = 0; $i < @$new_tokens; $i += 3) {
8859010023.5ms my $value = $new_tokens->[ $i + 1 ];
8869010017.9ms my $name = $new_tokens->[ $i ];
8879010013.3ms my $line = $new_tokens->[ $i + 2 ];
8889010085.4ms my $push = {
889 name => $name,
890 line => $line,
891 column => $column,
892 value => $value,
893 };
8949010024.7ms $column += length $value unless $name eq 'CONTEXT';
8959010012.9ms push @$next, $push;
8969010025.4ms if ($name eq 'EOL') {
897 $column = 0;
898 }
899 }
9006119434.6ms6119429.5ms $self->set_offset($column);
# spent 29.5ms making 61194 calls to YAML::PP::Lexer::set_offset, avg 483ns/call
9016119481.0ms return $next;
902}
903
904
# spent 52.5ms (48.4+4.12) within YAML::PP::Lexer::push_subtokens which was called 2046 times, avg 26µs/call: # 2045 times (48.3ms+4.12ms) by YAML::PP::Lexer::fetch_quoted at line 683, avg 26µs/call # once (52µs+2µs) by YAML::PP::Lexer::fetch_block at line 613
sub push_subtokens {
9052046574µs my ($self, $token, $subtokens) = @_;
90620461.57ms2046977µs my $next = $self->next_tokens;
# spent 977µs making 2046 calls to YAML::PP::Lexer::next_tokens, avg 478ns/call
90720461.77ms2046657µs my $line = $self->line;
# spent 657µs making 2046 calls to YAML::PP::Lexer::line, avg 321ns/call
90820461.23ms2046935µs my $column = $self->offset;
# spent 935µs making 2046 calls to YAML::PP::Lexer::offset, avg 457ns/call
9092046837µs $token->{column} = $column;
9102046941µs $token->{subtokens} = \my @sub;
911
91220463.32ms for (my $i = 0; $i < @$subtokens; $i+=3) {
91361522.95ms my $name = $subtokens->[ $i ];
91461522.54ms my $value = $subtokens->[ $i + 1 ];
91561521.32ms my $line = $subtokens->[ $i + 2 ];
91661524.99ms my $push = {
917 name => $subtokens->[ $i ],
918 line => $line,
919 column => $column,
920 };
92161522.42ms if (ref $value eq 'HASH') {
92220455.75ms %$push = ( %$push, %$value );
92320451.31ms $column += length $value->{orig};
924 }
925 else {
92641071.58ms $push->{value} = $value;
9274107855µs $column += length $value;
928 }
92961521.36ms if ($push->{name} eq 'EOL') {
930 $column = 0;
931 }
93261522.02ms push @sub, $push;
933 }
9342046927µs $token->{line} = $sub[0]->{line};
9352046617µs push @$next, $token;
93620462.01ms20461.56ms $self->set_offset($column);
# spent 1.56ms making 2046 calls to YAML::PP::Lexer::set_offset, avg 761ns/call
93720463.04ms 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
962140µs1;
 
# spent 19.3ms within YAML::PP::Lexer::CORE:match which was called 13361 times, avg 1µs/call: # 13360 times (19.3ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 148, avg 1µs/call # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 574
sub YAML::PP::Lexer::CORE:match; # opcode
# spent 29µs within YAML::PP::Lexer::CORE:qr which was called 11 times, avg 3µs/call: # 4 times (14µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 4µs/call # once (5µs+0s) by YAML::PP::Parser::BEGIN@18 at line 50 # once (3µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # once (2µs+0s) by YAML::PP::Parser::BEGIN@18 at line 120 # once (2µs+0s) by YAML::PP::Parser::BEGIN@18 at line 51 # once (1µs+0s) by YAML::PP::Parser::BEGIN@18 at line 122 # 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
sub YAML::PP::Lexer::CORE:qr; # opcode
# spent 154ms within YAML::PP::Lexer::CORE:regcomp which was called 58385 times, avg 3µs/call: # 18718 times (105ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 6µs/call # 18718 times (14.0ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 746ns/call # 13953 times (29.8ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 2µs/call # 2045 times (1.82ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 890ns/call # 2045 times (1.13ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 551ns/call # 2045 times (851µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 416ns/call # 666 times (386µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 580ns/call # 88 times (65µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 270, avg 739ns/call # 88 times (52µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 591ns/call # 6 times (37µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 6µs/call # 3 times (237µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 79µs/call # 3 times (17µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 6µs/call # once (141µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # once (22µs+0s) by YAML::PP::Parser::BEGIN@18 at line 50 # once (18µs+0s) by YAML::PP::Parser::BEGIN@18 at line 120 # once (13µs+0s) by YAML::PP::Parser::BEGIN@18 at line 122 # once (12µs+0s) by YAML::PP::Parser::BEGIN@18 at line 121 # once (12µs+0s) by YAML::PP::Parser::BEGIN@18 at line 51 # once (5µs+0s) by YAML::PP::Lexer::fetch_block at line 525
sub YAML::PP::Lexer::CORE:regcomp; # opcode
# spent 148ms within YAML::PP::Lexer::CORE:subst which was called 75042 times, avg 2µs/call: # 18718 times (82.7ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 4µs/call # 18718 times (19.0ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 1µs/call # 13953 times (20.0ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 1µs/call # 13953 times (13.5ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 302, avg 969ns/call # 2045 times (4.16ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 2µs/call # 2045 times (3.99ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 2µs/call # 2045 times (2.03ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 994ns/call # 2045 times (1.29ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 727, avg 632ns/call # 666 times (753µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 1µs/call # 666 times (595µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 331, avg 893ns/call # 88 times (41µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 466ns/call # 88 times (26µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 270, avg 295ns/call # 6 times (6µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 1µs/call # 3 times (3µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 1µs/call # 2 times (3µs+0s) by YAML::PP::Lexer::fetch_block at line 531, avg 2µs/call # once (1µ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.