← Index
NYTProf Performance Profile   « line view »
For ../prof.pl
  Run on Wed Dec 14 15:57:08 2022
Reported on Wed Dec 14 16:00:36 2022

Filename/Users/ether/.perlbrew/libs/36.0@std/lib/perl5/YAML/PP/Lexer.pm
StatementsExecuted 3206241 statements in 3.50s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
61685101844ms976msYAML::PP::Lexer::::_push_tokens YAML::PP::Lexer::_push_tokens
2792631556ms1.18sYAML::PP::Lexer::::_fetch_next_tokens YAML::PP::Lexer::_fetch_next_tokens
1888411504ms2.06sYAML::PP::Lexer::::fetch_plain YAML::PP::Lexer::fetch_plain
1345111294ms1.17sYAML::PP::Lexer::::fetch_next_tokens YAML::PP::Lexer::fetch_next_tokens
1849731267ms417msYAML::PP::Lexer::::_fetch_next_line YAML::PP::Lexer::_fetch_next_line
58874191208ms208msYAML::PP::Lexer::::CORE:regcomp YAML::PP::Lexer::CORE:regcomp (opcode)
75666161207ms207msYAML::PP::Lexer::::CORE:subst YAML::PP::Lexer::CORE:subst (opcode)
16078422182.6ms82.6msYAML::PP::Lexer::::line YAML::PP::Lexer::line
20561170.0ms275msYAML::PP::Lexer::::fetch_quoted YAML::PP::Lexer::fetch_quoted
20572163.2ms68.0msYAML::PP::Lexer::::push_subtokens YAML::PP::Lexer::push_subtokens
20561159.8ms74.8msYAML::PP::Lexer::::_read_quoted_tokens YAML::PP::Lexer::_read_quoted_tokens
637422142.3ms42.3msYAML::PP::Lexer::::set_offset YAML::PP::Lexer::set_offset
771944241.5ms41.5msYAML::PP::Lexer::::next_tokens YAML::PP::Lexer::next_tokens
762157240.7ms40.7msYAML::PP::Lexer::::flowcontext YAML::PP::Lexer::flowcontext
637422135.0ms35.0msYAML::PP::Lexer::::offset YAML::PP::Lexer::offset
134562127.2ms27.2msYAML::PP::Lexer::::CORE:match YAML::PP::Lexer::CORE:match (opcode)
374751120.5ms20.5msYAML::PP::Lexer::::context YAML::PP::Lexer::context
394384120.4ms20.4msYAML::PP::Lexer::::next_line YAML::PP::Lexer::next_line
269118118.5ms18.5msYAML::PP::Lexer::::set_next_line YAML::PP::Lexer::set_next_line
134551110.1ms10.1msYAML::PP::Lexer::::inc_line YAML::PP::Lexer::inc_line
13455119.29ms9.29msYAML::PP::Lexer::::set_block YAML::PP::Lexer::set_block
14025117.99ms7.99msYAML::PP::Lexer::::block YAML::PP::Lexer::block
13456117.95ms7.95msYAML::PP::Lexer::::reader YAML::PP::Lexer::reader
1112.75ms3.03msYAML::PP::Lexer::::BEGIN@10 YAML::PP::Lexer::BEGIN@10
1102111.10ms1.10msYAML::PP::Lexer::::set_flowcontext YAML::PP::Lexer::set_flowcontext
111202µs550µsYAML::PP::Lexer::::fetch_block YAML::PP::Lexer::fetch_block
17621125µs125µsYAML::PP::Lexer::::set_context YAML::PP::Lexer::set_context
11124µs27µsYAML::PP::Parser::::BEGIN@1YAML::PP::Parser::BEGIN@1
33216µs16µsYAML::PP::Lexer::::init YAML::PP::Lexer::init
118112µs12µsYAML::PP::Lexer::::CORE:qr YAML::PP::Lexer::CORE:qr (opcode)
11110µs18µsYAML::PP::Lexer::::new YAML::PP::Lexer::new
1118µs27µsYAML::PP::Lexer::::BEGIN@11 YAML::PP::Lexer::BEGIN@11
1114µs32µsYAML::PP::Lexer::::BEGIN@7 YAML::PP::Lexer::BEGIN@7
1114µs22µsYAML::PP::Lexer::::BEGIN@8 YAML::PP::Lexer::BEGIN@8
1114µs4µsYAML::PP::Lexer::::set_reader YAML::PP::Lexer::set_reader
1114µs28µsYAML::PP::Parser::::BEGIN@2.285YAML::PP::Parser::BEGIN@2.285
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
1233µs230µs
# spent 27µs (24+3) within YAML::PP::Parser::BEGIN@1 which was called: # once (24µs+3µs) by YAML::PP::Parser::BEGIN@18 at line 1
use strict;
# spent 27µs making 1 call to YAML::PP::Parser::BEGIN@1 # spent 3µs making 1 call to strict::import
2239µs252µs
# spent 28µs (4+24) within YAML::PP::Parser::BEGIN@2.285 which was called: # once (4µs+24µs) by YAML::PP::Parser::BEGIN@18 at line 2
use warnings;
# spent 28µs making 1 call to YAML::PP::Parser::BEGIN@2.285 # spent 24µs making 1 call to warnings::import
3package YAML::PP::Lexer;
4
511µsour $VERSION = '0.035'; # VERSION
6
7227µs260µs
# spent 32µs (4+28) within YAML::PP::Lexer::BEGIN@7 which was called: # once (4µs+28µs) by YAML::PP::Parser::BEGIN@18 at line 7
use constant TRACE => $ENV{YAML_PP_TRACE} ? 1 : 0;
# spent 32µs making 1 call to YAML::PP::Lexer::BEGIN@7 # spent 28µs making 1 call to constant::import
8217µs240µs
# spent 22µs (4+18) within YAML::PP::Lexer::BEGIN@8 which was called: # once (4µs+18µs) by YAML::PP::Parser::BEGIN@18 at line 8
use constant DEBUG => ($ENV{YAML_PP_DEBUG} || $ENV{YAML_PP_TRACE}) ? 1 : 0;
# spent 22µs making 1 call to YAML::PP::Lexer::BEGIN@8 # spent 18µs making 1 call to constant::import
9
102546µs23.18ms
# spent 3.03ms (2.75+283µs) within YAML::PP::Lexer::BEGIN@10 which was called: # once (2.75ms+283µs) by YAML::PP::Parser::BEGIN@18 at line 10
use YAML::PP::Grammar qw/ $GRAMMAR /;
# spent 3.03ms making 1 call to YAML::PP::Lexer::BEGIN@10 # spent 147µs making 1 call to Exporter::import
1124.84ms246µs
# spent 27µs (8+19) within YAML::PP::Lexer::BEGIN@11 which was called: # once (8µs+19µ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 19µs making 1 call to Exporter::import
12
13
# spent 18µs (10+8) within YAML::PP::Lexer::new which was called: # once (10µ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},
1712µs }, $class;
1813µs18µs $self->init;
# spent 8µs making 1 call to YAML::PP::Lexer::init
1913µs return $self;
20}
21
22
# spent 16µ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 (7µ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 {
2333µs my ($self) = @_;
2435µs $self->{next_tokens} = [];
2532µs $self->{next_line} = undef;
2631µs $self->{line} = 0;
2732µs $self->{offset} = 0;
2839µs $self->{flowcontext} = 0;
29}
30
313943862.9ms
# spent 20.4ms within YAML::PP::Lexer::next_line which was called 39438 times, avg 517ns/call: # 18884 times (10.3ms+0s) by YAML::PP::Lexer::fetch_plain at line 367, avg 548ns/call # 18497 times (8.84ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 136, avg 478ns/call # 2056 times (1.22ms+0s) by YAML::PP::Lexer::fetch_quoted at line 620, avg 593ns/call # once (1µs+0s) by YAML::PP::Lexer::fetch_block at line 519
sub next_line { return $_[0]->{next_line} }
322691141.5ms
# spent 18.5ms within YAML::PP::Lexer::set_next_line which was called 26911 times, avg 687ns/call: # 13455 times (8.21ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 150, avg 610ns/call # 6386 times (4.92ms+0s) by YAML::PP::Lexer::fetch_plain at line 398, avg 770ns/call # 5040 times (3.85ms+0s) by YAML::PP::Lexer::fetch_plain at line 392, avg 764ns/call # 1424 times (1.08ms+0s) by YAML::PP::Lexer::fetch_quoted at line 706, avg 757ns/call # 598 times (432µs+0s) by YAML::PP::Lexer::fetch_quoted at line 697, avg 722ns/call # 6 times (10µs+0s) by YAML::PP::Lexer::fetch_block at line 561, avg 2µs/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] }
331345619.3ms
# spent 7.95ms within YAML::PP::Lexer::reader which was called 13456 times, avg 591ns/call: # 13456 times (7.95ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 141, avg 591ns/call
sub reader { return $_[0]->{reader} }
3419µ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] }
3577194131ms
# spent 41.5ms within YAML::PP::Lexer::next_tokens which was called 77194 times, avg 537ns/call: # 61685 times (32.3ms+0s) by YAML::PP::Lexer::_push_tokens at line 880, avg 523ns/call # 13451 times (7.95ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 182, avg 591ns/call # 2057 times (1.25ms+0s) by YAML::PP::Lexer::push_subtokens at line 906, avg 608ns/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} }
36160784231ms
# spent 82.6ms within YAML::PP::Lexer::line which was called 160784 times, avg 514ns/call: # 61685 times (24.9ms+0s) by YAML::PP::Lexer::_push_tokens at line 881, avg 404ns/call # 18884 times (12.1ms+0s) by YAML::PP::Lexer::fetch_plain at line 381, avg 641ns/call # 18884 times (8.12ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 355, avg 430ns/call # 14054 times (6.20ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 295, avg 441ns/call # 13449 times (7.50ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 558ns/call # 7598 times (3.97ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 307, avg 522ns/call # 6456 times (3.46ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 303, avg 536ns/call # 5040 times (9.42ms+0s) by YAML::PP::Lexer::fetch_plain at line 391, avg 2µs/call # 2057 times (846µs+0s) by YAML::PP::Lexer::push_subtokens at line 907, avg 411ns/call # 2057 times (765µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 278, avg 372ns/call # 2056 times (1.34ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 742, avg 651ns/call # 2056 times (1.20ms+0s) by YAML::PP::Lexer::fetch_quoted at line 626, avg 582ns/call # 2056 times (851µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 748, avg 414ns/call # 1791 times (706µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 340, avg 394ns/call # 1424 times (600µs+0s) by YAML::PP::Lexer::fetch_quoted at line 704, avg 421ns/call # 689 times (340µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 336, avg 493ns/call # 529 times (264µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 256, avg 499ns/call # 15 times (11µs+0s) by YAML::PP::Lexer::fetch_block at line 605, avg 733ns/call # once (2µs+0s) by YAML::PP::Lexer::fetch_block at line 526 # once (1µ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 538
sub line { return $_[0]->{line} }
37sub set_line { $_[0]->{line} = $_[1] }
3863742142ms
# spent 35.0ms within YAML::PP::Lexer::offset which was called 63742 times, avg 549ns/call: # 61685 times (33.9ms+0s) by YAML::PP::Lexer::_push_tokens at line 882, avg 549ns/call # 2057 times (1.08ms+0s) by YAML::PP::Lexer::push_subtokens at line 908, avg 526ns/call
sub offset { return $_[0]->{offset} }
3963742105ms
# spent 42.3ms within YAML::PP::Lexer::set_offset which was called 63742 times, avg 664ns/call: # 61685 times (40.7ms+0s) by YAML::PP::Lexer::_push_tokens at line 900, avg 659ns/call # 2057 times (1.61ms+0s) by YAML::PP::Lexer::push_subtokens at line 936, avg 785ns/call
sub set_offset { $_[0]->{offset} = $_[1] }
401345521.8ms
# spent 10.1ms within YAML::PP::Lexer::inc_line which was called 13455 times, avg 747ns/call: # 13455 times (10.1ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 147, avg 747ns/call
sub inc_line { return $_[0]->{line}++ }
413747554.1ms
# spent 20.5ms within YAML::PP::Lexer::context which was called 37475 times, avg 546ns/call: # 37475 times (20.5ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 263, avg 546ns/call
sub context { return $_[0]->{context} }
42176302µs
# spent 125µs within YAML::PP::Lexer::set_context which was called 176 times, avg 710ns/call: # 88 times (74µs+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 841ns/call # 88 times (51µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 275, avg 580ns/call
sub set_context { $_[0]->{context} = $_[1] }
4376215109ms
# spent 40.7ms within YAML::PP::Lexer::flowcontext which was called 76215 times, avg 534ns/call: # 20941 times (11.5ms+0s) by YAML::PP::Parser::parse_tokens at line 379 of YAML/PP/Parser.pm, avg 550ns/call # 18884 times (8.00ms+0s) by YAML::PP::Lexer::fetch_plain at line 371, avg 423ns/call # 14054 times (8.35ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 594ns/call # 13449 times (8.75ms+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 651ns/call # 5040 times (2.18ms+0s) by YAML::PP::Lexer::fetch_plain at line 405, avg 432ns/call # 2056 times (1.09ms+0s) by YAML::PP::Lexer::fetch_quoted at line 694, avg 531ns/call # 1791 times (837µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 342, avg 467ns/call
sub flowcontext { return $_[0]->{flowcontext} }
4411021.93ms
# spent 1.10ms within YAML::PP::Lexer::set_flowcontext which was called 1102 times, avg 1µs/call: # 1102 times (1.10ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 343, avg 1µs/call
sub set_flowcontext { $_[0]->{flowcontext} = $_[1] }
451402521.9ms
# spent 7.99ms within YAML::PP::Lexer::block which was called 14025 times, avg 570ns/call: # 14025 times (7.99ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 286, avg 570ns/call
sub block { return $_[0]->{block} }
461345524.6ms
# spent 9.29ms within YAML::PP::Lexer::set_block which was called 13455 times, avg 690ns/call: # 13455 times (9.29ms+0s) by YAML::PP::Lexer::_fetch_next_line at line 146, avg 690ns/call
sub set_block { $_[0]->{block} = $_[1] }
47
4810smy $RE_WS = '[\t ]';
4910smy $RE_LB = '[\r\n]';
50133µs218µsmy $RE_DOC_END = qr/\A(\.\.\.)(?=$RE_WS|$)/m;
# spent 16µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 2µs making 1 call to YAML::PP::Lexer::CORE:qr
51110µs26µsmy $RE_DOC_START = qr/\A(---)(?=$RE_WS|$)/m;
# spent 6µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 0s making 1 call to YAML::PP::Lexer::CORE:qr
52117µs214µsmy $RE_EOL = qr/\A($RE_WS+#.*|$RE_WS+)\z/;
# spent 10µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 4µ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-]';
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]';
6610smy $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}]';
6910smy $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
9713µ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
10210smy $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)*";
10411µ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*
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
120111µs26µsmy $RE_SEQSTART = qr/\A(-)(?=$RE_WS|$)/m;
# spent 6µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 0s making 1 call to YAML::PP::Lexer::CORE:qr
12119µs27µsmy $RE_COMPLEX = qr/(\?)(?=$RE_WS|$)/m;
# spent 6µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
122111µs27µsmy $RE_COMPLEXCOLON = qr/\A(:)(?=$RE_WS|$)/m;
# spent 6µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 1µs making 1 call to YAML::PP::Lexer::CORE:qr
12311µsmy $RE_ANCHOR = "&$RE_ANCHOR_CAR+";
12410smy $RE_ALIAS = "\\*$RE_ANCHOR_CAR+";
125
126
1271116µs7107µsmy %REGEXES = (
# spent 104µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 35µs/call # spent 3µs making 4 calls to YAML::PP::Lexer::CORE:qr, avg 750ns/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 417ms (267+150) within YAML::PP::Lexer::_fetch_next_line which was called 18497 times, avg 23µs/call: # 13451 times (161ms+99.2ms) by YAML::PP::Lexer::fetch_next_tokens at line 185, avg 19µs/call # 5040 times (105ms+50.7ms) by YAML::PP::Lexer::fetch_plain at line 412, avg 31µs/call # 6 times (130µs+46µs) by YAML::PP::Lexer::fetch_block at line 562, avg 29µs/call
sub _fetch_next_line {
135184974.43ms my ($self) = @_;
1361849716.0ms184978.84ms my $next_line = $self->next_line;
# spent 8.84ms making 18497 calls to YAML::PP::Lexer::next_line, avg 478ns/call
1371849713.0ms if (defined $next_line ) {
138 return $next_line;
139 }
140
1411345632.6ms2691286.4ms my $line = $self->reader->readline;
# spent 78.4ms making 13456 calls to YAML::PP::Reader::File::readline, avg 6µs/call # spent 7.95ms making 13456 calls to YAML::PP::Lexer::reader, avg 591ns/call
142134563.36ms unless (defined $line) {
14311µs11µs $self->set_next_line(undef);
# spent 1µs making 1 call to YAML::PP::Lexer::set_next_line
14412µs return;
145 }
1461345511.7ms134559.29ms $self->set_block(1);
# spent 9.29ms making 13455 calls to YAML::PP::Lexer::set_block, avg 690ns/call
1471345512.7ms1345510.1ms $self->inc_line;
# spent 10.1ms making 13455 calls to YAML::PP::Lexer::inc_line, avg 747ns/call
1481345567.5ms1345527.2ms $line =~ m/\A( *)([^\r\n]*)([\r\n]|\z)/ or die "Unexpected";
# spent 27.2ms making 13455 calls to YAML::PP::Lexer::CORE:match, avg 2µs/call
1491345526.5ms $next_line = [ $1, $2, $3 ];
150134559.86ms134558.21ms $self->set_next_line($next_line);
# spent 8.21ms making 13455 calls to YAML::PP::Lexer::set_next_line, avg 610ns/call
151 # $ESCAPE_CHAR from YAML.pm
152134557.74ms if ($line =~ tr/\x00-\x08\x0b-\x0c\x0e-\x1f//) {
153 $self->exception("Control characters are not allowed");
154 }
155
1561345527.9ms return $next_line;
157}
158
15916µ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.17s (294ms+874ms) within YAML::PP::Lexer::fetch_next_tokens which was called 13451 times, avg 87µs/call: # 13451 times (294ms+874ms) by YAML::PP::Parser::lex_next_tokens at line 179 of YAML/PP/Parser.pm, avg 87µs/call
sub fetch_next_tokens {
181134513.68ms my ($self) = @_;
1821345111.8ms134517.95ms my $next = $self->next_tokens;
# spent 7.95ms making 13451 calls to YAML::PP::Lexer::next_tokens, avg 591ns/call
183134513.61ms return $next if @$next;
184
1851345115.8ms13451261ms my $next_line = $self->_fetch_next_line;
# spent 261ms making 13451 calls to YAML::PP::Lexer::_fetch_next_line, avg 19µs/call
186134512.04ms if (not $next_line) {
187 return [];
188 }
189
190134505.73ms my $spaces = $next_line->[0];
191134505.87ms my $yaml = \$next_line->[1];
192134505.11ms if (not length $$yaml) {
193 $self->_push_tokens([ EOL => join('', @$next_line), $self->line ]);
194 $self->set_next_line(undef);
195 return $next;
196 }
1971345014.2ms 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 }
202134503.94ms 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 }
2081345023.5ms134638.83ms if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 8.75ms making 13449 calls to YAML::PP::Lexer::flowcontext, avg 651ns/call # spent 44µs making 6 calls to YAML::PP::Lexer::CORE:regcomp, avg 7µs/call # spent 27µ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 1µ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 {
2171344927.1ms26898192ms $self->_push_tokens([ SPACE => $spaces, $self->line ]);
# spent 184ms making 13449 calls to YAML::PP::Lexer::_push_tokens, avg 14µs/call # spent 7.50ms making 13449 calls to YAML::PP::Lexer::line, avg 558ns/call
218 }
219
2201345015.4ms13450405ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 405ms making 13450 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 30µs/call
221134502.05ms11µs unless ($partial) {
# spent 1µs making 1 call to YAML::PP::Lexer::set_next_line
222 $self->set_next_line(undef);
223 }
2241345035.7ms return $next;
225}
226
22710smy %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 );
23211µsmy %CONTEXT = ( '"' => 1, "'" => 1, '>' => 1, '|' => 1 );
233
23412µ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;
23817µ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.18s (556ms+624ms) within YAML::PP::Lexer::_fetch_next_tokens which was called 27926 times, avg 42µs/call: # 13844 times (388ms+357ms) by YAML::PP::Lexer::fetch_plain at line 397, avg 54µs/call # 13450 times (153ms+252ms) by YAML::PP::Lexer::fetch_next_tokens at line 220, avg 30µs/call # 632 times (15.7ms+15.2ms) by YAML::PP::Lexer::fetch_quoted at line 696, avg 49µs/call
sub _fetch_next_tokens {
246 TRACE and warn __PACKAGE__.':'.__LINE__.": _fetch_next_tokens\n";
247279266.53ms my ($self, $next_line) = @_;
248
2492792610.8ms my $yaml = \$next_line->[1];
250279266.38ms my $eol = $next_line->[2];
251
252279263.67ms my @tokens;
253
254279264.53ms while (1) {
255380047.93ms unless (length $$yaml) {
256529981µs529264µs push @tokens, ( EOL => $eol, $self->line );
# spent 264µs making 529 calls to YAML::PP::Lexer::line, avg 499ns/call
257529499µs5299.79ms $self->_push_tokens(\@tokens);
# spent 9.79ms making 529 calls to YAML::PP::Lexer::_push_tokens, avg 19µs/call
2585291.46ms return;
259 }
2603747517.0ms my $first = substr($$yaml, 0, 1);
261374754.66ms my $plain = 0;
262
2633747527.2ms3747520.5ms if ($self->context) {
# spent 20.5ms making 37475 calls to YAML::PP::Lexer::context, avg 546ns/call
26488448µs176134µs if ($$yaml =~ s/\A($RE_WS*)://) {
# spent 83µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 943ns/call # spent 51µs making 88 calls to YAML::PP::Lexer::CORE:subst, avg 580ns/call
265 push @tokens, ( WS => $1, $self->line ) if $1;
266 push @tokens, ( COLON => ':', $self->line );
267 $self->set_context(0);
268 next;
269 }
27088326µs176119µs if ($$yaml =~ s/\A($RE_WS*(?: #.*))\z//) {
# spent 93µs making 88 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/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 }
27588104µs8851µs $self->set_context(0);
# spent 51µs making 88 calls to YAML::PP::Lexer::set_context, avg 580ns/call
276 }
2773747536.5ms if ($CONTEXT{ $first }) {
27820572.83ms2057765µs push @tokens, ( CONTEXT => $first, $self->line );
# spent 765µs making 2057 calls to YAML::PP::Lexer::line, avg 372ns/call
27920574.19ms205737.5ms $self->_push_tokens(\@tokens);
# spent 37.5ms making 2057 calls to YAML::PP::Lexer::_push_tokens, avg 18µs/call
28020575.19ms return 1;
281 }
282 elsif ($COLON_DASH_QUESTION{ $first }) {
283140546.03ms my $token_name = $TOKEN_NAMES{ $first };
28414054116ms2810870.0ms if ($$yaml =~ s/\A\Q$first\E($RE_WS+|\z)//) {
# spent 42.5ms making 14054 calls to YAML::PP::Lexer::CORE:regcomp, avg 3µs/call # spent 27.5ms making 14054 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call
285140546.19ms my $after = $1;
2861405421.7ms2807916.3ms if (not $self->flowcontext and not $self->block) {
# spent 8.35ms making 14054 calls to YAML::PP::Lexer::flowcontext, avg 594ns/call # spent 7.99ms making 14025 calls to YAML::PP::Lexer::block, avg 570ns/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 }
291140546.73ms if ($after =~ tr/\t//) {
292 $self->set_block(0);
293 }
294140544.94ms my $token_name = $TOKEN_NAMES{ $first };
2951405419.3ms140546.20ms push @tokens, ( $token_name => $first, $self->line );
# spent 6.20ms making 14054 calls to YAML::PP::Lexer::line, avg 441ns/call
296140545.86ms if (not defined $1) {
297 push @tokens, ( EOL => $eol, $self->line );
298 $self->_push_tokens(\@tokens);
299 return;
300 }
301140544.50ms my $ws = $1;
3021405441.7ms1405420.3ms if ($$yaml =~ s/\A(#.*|)\z//) {
# spent 20.3ms making 14054 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
303645616.4ms64563.46ms push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
# spent 3.46ms making 6456 calls to YAML::PP::Lexer::line, avg 536ns/call
30464565.66ms6456101ms $self->_push_tokens(\@tokens);
# spent 101ms making 6456 calls to YAML::PP::Lexer::_push_tokens, avg 16µs/call
305645622.8ms return;
306 }
307759810.6ms75983.97ms push @tokens, ( WS => $ws, $self->line );
# spent 3.97ms making 7598 calls to YAML::PP::Lexer::line, avg 522ns/call
30875988.96ms 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") {
3296894.31ms13781.70ms if ($$yaml =~ s/\A($RE_WS+)//) {
# spent 1.10ms making 689 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call # spent 598µs making 689 calls to YAML::PP::Lexer::CORE:regcomp, avg 868ns/call
330689375µs my $ws = $1;
3316891.73ms689795µs if ($$yaml =~ s/\A((?:#.*)?\z)//) {
# spent 795µs making 689 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call
332 push @tokens, ( EOL => $ws . $1 . $eol, $self->line );
333 $self->_push_tokens(\@tokens);
334 return;
335 }
336689949µs689340µs push @tokens, ( WS => $ws, $self->line );
# spent 340µs making 689 calls to YAML::PP::Lexer::line, avg 493ns/call
337 }
338 }
339 elsif ($FLOW{ $first }) {
34017912.76ms1791706µs push @tokens, ( $TOKEN_NAMES{ $first } => $first, $self->line );
# spent 706µs making 1791 calls to YAML::PP::Lexer::line, avg 394ns/call
34117912.13ms substr($$yaml, 0, 1, '');
34217911.33ms1791837µs my $flowcontext = $self->flowcontext;
# spent 837µs making 1791 calls to YAML::PP::Lexer::flowcontext, avg 467ns/call
34317912.80ms11021.10ms if ($first eq '{' or $first eq '[') {
# spent 1.10ms making 1102 calls to YAML::PP::Lexer::set_flowcontext, avg 1µs/call
344 $self->set_flowcontext(++$flowcontext);
345 }
346 elsif ($first eq '}' or $first eq ']') {
347 $self->set_flowcontext(--$flowcontext);
348 }
349 }
350 else {
351188842.82ms $plain = 1;
352 }
353
354213644.31ms if ($plain) {
3551888417.7ms188848.12ms push @tokens, ( CONTEXT => '', $self->line );
# spent 8.12ms making 18884 calls to YAML::PP::Lexer::line, avg 430ns/call
3561888413.4ms18884321ms $self->_push_tokens(\@tokens);
# spent 321ms making 18884 calls to YAML::PP::Lexer::_push_tokens, avg 17µs/call
3571888460.2ms return 1;
358 }
359
360 }
361
362 return;
363}
364
365
# spent 2.06s (504ms+1.56) within YAML::PP::Lexer::fetch_plain which was called 18884 times, avg 109µs/call: # 18884 times (504ms+1.56s) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 109µs/call
sub fetch_plain {
366188847.38ms my ($self, $indent, $context) = @_;
3671888417.1ms1888410.3ms my $next_line = $self->next_line;
# spent 10.3ms making 18884 calls to YAML::PP::Lexer::next_line, avg 548ns/call
368188847.20ms my $yaml = \$next_line->[1];
369188846.09ms my $eol = $next_line->[2];
370188844.54ms my $REGEX = $RE_PLAIN_WORDS;
3711888412.4ms188848.00ms if ($self->flowcontext) {
# spent 8.00ms making 18884 calls to YAML::PP::Lexer::flowcontext, avg 423ns/call
372 $REGEX = $RE_PLAIN_WORDS_FLOW;
373 }
374
375188842.91ms my @tokens;
37618884320ms37768250ms unless ($$yaml =~ s/\A($REGEX)//) {
# spent 138ms making 18884 calls to YAML::PP::Lexer::CORE:regcomp, avg 7µs/call # spent 112ms making 18884 calls to YAML::PP::Lexer::CORE:subst, avg 6µs/call
377 $self->_push_tokens(\@tokens);
378 $self->exception("Invalid plain scalar");
379 }
3801888415.6ms my $plain = $1;
3811888426.6ms1888412.1ms push @tokens, ( PLAIN => $plain, $self->line );
# spent 12.1ms making 18884 calls to YAML::PP::Lexer::line, avg 641ns/call
382
38318884105ms3776850.4ms if ($$yaml =~ s/\A(?:($RE_WS+#.*)|($RE_WS*))\z//) {
# spent 29.7ms making 18884 calls to YAML::PP::Lexer::CORE:subst, avg 2µs/call # spent 20.7ms making 18884 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/call
38450402.77ms 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 {
39150409.21ms50409.42ms push @tokens, ( EOL => $2. $eol, $self->line );
# spent 9.42ms making 5040 calls to YAML::PP::Lexer::line, avg 2µs/call
39250405.35ms50403.85ms $self->set_next_line(undef);
# spent 3.85ms making 5040 calls to YAML::PP::Lexer::set_next_line, avg 764ns/call
393 }
394 }
395 else {
3961384413.1ms13844192ms $self->_push_tokens(\@tokens);
# spent 192ms making 13844 calls to YAML::PP::Lexer::_push_tokens, avg 14µs/call
3971384414.2ms13844745ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 745ms making 13844 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 54µs/call
398138447.65ms63864.92ms if (not $partial) {
# spent 4.92ms making 6386 calls to YAML::PP::Lexer::set_next_line, avg 770ns/call
399 $self->set_next_line(undef);
400 }
4011384457.0ms return;
402 }
403
40450401.60ms my $RE2 = $RE_PLAIN_WORDS2;
40550404.65ms50402.18ms if ($self->flowcontext) {
# spent 2.18ms making 5040 calls to YAML::PP::Lexer::flowcontext, avg 432ns/call
406 $RE2 = $RE_PLAIN_WORDS_FLOW2;
407 }
40850401.28ms my $fetch_next = 0;
40950403.69ms my @lines = ($plain);
41050401.28ms my @next;
41150401.04ms LOOP: while (1) {
41250409.29ms5040156ms $next_line = $self->_fetch_next_line;
# spent 156ms making 5040 calls to YAML::PP::Lexer::_fetch_next_line, avg 31µs/call
41350401.13ms if (not $next_line) {
414 last LOOP;
415 }
41650402.46ms my $spaces = $next_line->[0];
41750408.87ms my $yaml = \$next_line->[1];
41850402.05ms my $eol = $next_line->[2];
419
42050401.77ms 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.61ms622µs if (not $spaces and $$yaml =~ s/\A(---|\.\.\.)(?=$RE_WS|\z)//) {
# spent 20µs making 3 calls to YAML::PP::Lexer::CORE:regcomp, avg 7µ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 }
43250405.15ms if ((length $spaces) < $indent) {
43350405.59ms 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.74ms while (@lines > 1 and $lines[-1] eq '') {
493 pop @lines;
494 }
49550406.54ms 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 {
50550409.36ms5040112ms $self->_push_tokens([ @tokens, @next ]);
# spent 112ms making 5040 calls to YAML::PP::Lexer::_push_tokens, avg 22µs/call
506 }
50750404.29ms @tokens = ();
50850401.18ms if ($fetch_next) {
509 my $partial = $self->_fetch_next_tokens($next_line);
510 if (not $partial) {
511 $self->set_next_line(undef);
512 }
513 }
514504016.7ms return;
515}
516
517
# spent 550µs (202+348) within YAML::PP::Lexer::fetch_block which was called: # once (202µs+348µ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µ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 };
525123µs216µs $$yaml =~ s/\A\Q$context\E// or die "Unexpected";
# spent 14µs making 1 call to YAML::PP::Lexer::CORE:regcomp # spent 2µs making 1 call to YAML::PP::Lexer::CORE:subst
52612µs12µs push @tokens, ( $token_name => $context, $self->line );
# spent 2µs making 1 call to YAML::PP::Lexer::line
52711µs my $current_indent = $indent;
52810s my $started = 0;
52910s my $set_indent = 0;
53017µs my $chomp = '';
53118µ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])?//) {
53812µs10s push @tokens, ( BLOCK_SCALAR_CHOMP => $1, $self->line );
# spent 0s making 1 call to YAML::PP::Lexer::line
53910s $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µ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;
56010s while (1) {
56169µs610µs $self->set_next_line(undef);
# spent 10µs making 6 calls to YAML::PP::Lexer::set_next_line, avg 2µs/call
56269µs6176µs $next_line = $self->_fetch_next_line;
# spent 176µs making 6 calls to YAML::PP::Lexer::_fetch_next_line, avg 29µs/call
56360s if (not $next_line) {
564 last;
565 }
56662µs my $spaces = $next_line->[0];
56765µs my $content = $next_line->[1];
56862µs my $eol = $next_line->[2];
56964µs if (not $spaces and $content =~ m/\A(---|\.\.\.)(?=$RE_WS|\z)/) {
570 last;
571 }
57263µs if ((length $spaces) < $current_indent) {
57310s if (length $content) {
57415µ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 }
58652µ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;
60211µs $current_indent = length $spaces;
603 }
60452µs push @lines, $content;
605532µs1511µs push @tokens, (
# spent 11µs making 15 calls to YAML::PP::Lexer::line, avg 733ns/call
606 INDENT => $spaces, $self->line,
607 BLOCK_SCALAR_CONTENT => $content, $self->line,
608 EOL => $eol, $self->line,
609 );
610 }
61118µs123µs my $value = YAML::PP::Render->render_block_scalar($context, $chomp, \@lines);
# spent 23µs making 1 call to YAML::PP::Render::render_block_scalar
61212µs my @eol = splice @tokens, -3;
61313µs191µs $self->push_subtokens( { name => 'BLOCK_SCALAR', value => $value }, \@tokens );
# spent 91µs making 1 call to YAML::PP::Lexer::push_subtokens
61412µs113µs $self->_push_tokens([ @eol ]);
# spent 13µs making 1 call to YAML::PP::Lexer::_push_tokens
61517µs return 0;
616}
617
618
# spent 275ms (70.0+205) within YAML::PP::Lexer::fetch_quoted which was called 2056 times, avg 134µs/call: # 2056 times (70.0ms+205ms) by YAML::PP::Parser::parse_tokens at line 381 of YAML/PP/Parser.pm, avg 134µs/call
sub fetch_quoted {
61920561.08ms my ($self, $indent, $context) = @_;
62020562.43ms20561.22ms my $next_line = $self->next_line;
# spent 1.22ms making 2056 calls to YAML::PP::Lexer::next_line, avg 593ns/call
62120561.30ms my $yaml = \$next_line->[1];
62220561.02ms my $spaces = $next_line->[0];
623
62420561.37ms my $token_name = $TOKEN_NAMES{ $context };
625205615.2ms41127.35ms $$yaml =~ s/\A\Q$context// or die "Unexpected";;
# spent 5.48ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 3µs/call # spent 1.87ms making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 911ns/call
62620564.01ms20561.20ms my @tokens = ( $token_name => $context, $self->line );
# spent 1.20ms making 2056 calls to YAML::PP::Lexer::line, avg 582ns/call
627
6282056745µs my $start = 1;
6292056584µs my @values;
6302056496µs while (1) {
631
6322056487µ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.51ms205674.8ms my $v = $self->_read_quoted_tokens($start, $context, $yaml, \@tokens);
# spent 74.8ms making 2056 calls to YAML::PP::Lexer::_read_quoted_tokens, avg 36µs/call
6812056657µs push @values, $v;
68220561.12ms if ($tokens[-3] eq $token_name) {
68320566.78ms205667.9ms if ($start) {
# spent 67.9ms making 2056 calls to YAML::PP::Lexer::push_subtokens, avg 33µ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 }
69420562.14ms21441.17ms $self->set_context(1) if $self->flowcontext;
# spent 1.09ms making 2056 calls to YAML::PP::Lexer::flowcontext, avg 531ns/call # spent 74µs making 88 calls to YAML::PP::Lexer::set_context, avg 841ns/call
6952056956µs if (length $$yaml) {
696632776µs63231.0ms my $partial = $self->_fetch_next_tokens($next_line);
# spent 31.0ms making 632 calls to YAML::PP::Lexer::_fetch_next_tokens, avg 49µs/call
697632802µs598432µs if (not $partial) {
# spent 432µs making 598 calls to YAML::PP::Lexer::set_next_line, avg 722ns/call
698 $self->set_next_line(undef);
699 }
7006323.91ms return 0;
701 }
702 else {
70314241.33ms @tokens = ();
70414242.35ms1424600µs push @tokens, ( EOL => $next_line->[2], $self->line );
# spent 600µs making 1424 calls to YAML::PP::Lexer::line, avg 421ns/call
70514241.74ms142418.1ms $self->_push_tokens(\@tokens);
# spent 18.1ms making 1424 calls to YAML::PP::Lexer::_push_tokens, avg 13µs/call
70614241.37ms14241.08ms $self->set_next_line(undef);
# spent 1.08ms making 1424 calls to YAML::PP::Lexer::set_next_line, avg 757ns/call
70714247.34ms return;
708 }
709 }
710 $tokens[-2] .= $next_line->[2];
711 $self->set_next_line(undef);
712 $start = 0;
713 }
714}
715
716
# spent 74.8ms (59.8+15.0) within YAML::PP::Lexer::_read_quoted_tokens which was called 2056 times, avg 36µs/call: # 2056 times (59.8ms+15.0ms) by YAML::PP::Lexer::fetch_quoted at line 680, avg 36µs/call
sub _read_quoted_tokens {
71720561.25ms my ($self, $start, $first, $yaml, $tokens) = @_;
7182056854µs my $quoted = '';
7192056751µs my $decoded = '';
72020561.05ms my $token_name = $TOKEN_NAMES{ $first };
7212056661µs my $eol = '';
72220561.29ms if ($first eq "'") {
72320561.36ms my $regex = $REGEXES{SINGLEQUOTED};
724205616.3ms41127.81ms if ($$yaml =~ s/\A($regex)//) {
# spent 5.42ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 3µs/call # spent 2.39ms making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 1µs/call
72520562.86ms $quoted .= $1;
72620561.09ms $decoded .= $1;
72720564.42ms20561.64ms $decoded =~ s/''/'/g;
# spent 1.64ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 796ns/call
728 }
72920561.56ms 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.82ms my $value = { value => $decoded, orig => $quoted };
740
74120569.97ms41123.36ms if ($$yaml =~ s/\A$first//) {
# spent 2.39ms making 2056 calls to YAML::PP::Lexer::CORE:subst, avg 1µs/call # spent 967µs making 2056 calls to YAML::PP::Lexer::CORE:regcomp, avg 470ns/call
74220564.39ms20561.34ms if ($start) {
# spent 1.34ms making 2056 calls to YAML::PP::Lexer::line, avg 651ns/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.32ms2056851µs push @$tokens, ( $token_name => $first, $self->line );
# spent 851µs making 2056 calls to YAML::PP::Lexer::line, avg 414ns/call
74920564.97ms 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 976ms (844+132) within YAML::PP::Lexer::_push_tokens which was called 61685 times, avg 16µs/call: # 18884 times (279ms+41.4ms) by YAML::PP::Lexer::_fetch_next_tokens at line 356, avg 17µs/call # 13844 times (162ms+29.8ms) by YAML::PP::Lexer::fetch_plain at line 396, avg 14µs/call # 13449 times (157ms+26.9ms) by YAML::PP::Lexer::fetch_next_tokens at line 217, avg 14µs/call # 6456 times (87.0ms+13.5ms) by YAML::PP::Lexer::_fetch_next_tokens at line 304, avg 16µs/call # 5040 times (100ms+12.4ms) by YAML::PP::Lexer::fetch_plain at line 505, avg 22µs/call # 2057 times (33.5ms+4.04ms) by YAML::PP::Lexer::_fetch_next_tokens at line 279, avg 18µs/call # 1424 times (15.4ms+2.65ms) by YAML::PP::Lexer::fetch_quoted at line 705, avg 13µs/call # 529 times (8.79ms+1.00ms) by YAML::PP::Lexer::_fetch_next_tokens at line 257, avg 19µs/call # once (25µs+2µs) by YAML::PP::Lexer::fetch_next_tokens at line 208 # once (10µs+3µs) by YAML::PP::Lexer::fetch_block at line 614
sub _push_tokens {
8796168513.2ms my ($self, $new_tokens) = @_;
8806168542.7ms6168532.3ms my $next = $self->next_tokens;
# spent 32.3ms making 61685 calls to YAML::PP::Lexer::next_tokens, avg 523ns/call
8816168538.0ms6168524.9ms my $line = $self->line;
# spent 24.9ms making 61685 calls to YAML::PP::Lexer::line, avg 404ns/call
8826168542.1ms6168533.9ms my $column = $self->offset;
# spent 33.9ms making 61685 calls to YAML::PP::Lexer::offset, avg 549ns/call
883
8846168568.4ms for (my $i = 0; $i < @$new_tokens; $i += 3) {
8859085729.7ms my $value = $new_tokens->[ $i + 1 ];
8869085721.8ms my $name = $new_tokens->[ $i ];
8879085717.1ms my $line = $new_tokens->[ $i + 2 ];
88890857117ms my $push = {
889 name => $name,
890 line => $line,
891 column => $column,
892 value => $value,
893 };
8949085731.7ms $column += length $value unless $name eq 'CONTEXT';
8959085716.7ms push @$next, $push;
8969085734.4ms if ($name eq 'EOL') {
897 $column = 0;
898 }
899 }
9006168545.9ms6168540.7ms $self->set_offset($column);
# spent 40.7ms making 61685 calls to YAML::PP::Lexer::set_offset, avg 659ns/call
90161685139ms return $next;
902}
903
904
# spent 68.0ms (63.2+4.79) within YAML::PP::Lexer::push_subtokens which was called 2057 times, avg 33µs/call: # 2056 times (63.1ms+4.79ms) by YAML::PP::Lexer::fetch_quoted at line 683, avg 33µs/call # once (88µs+3µs) by YAML::PP::Lexer::fetch_block at line 613
sub push_subtokens {
9052057646µs my ($self, $token, $subtokens) = @_;
90620572.10ms20571.25ms my $next = $self->next_tokens;
# spent 1.25ms making 2057 calls to YAML::PP::Lexer::next_tokens, avg 608ns/call
90720572.06ms2057846µs my $line = $self->line;
# spent 846µs making 2057 calls to YAML::PP::Lexer::line, avg 411ns/call
90820571.86ms20571.08ms my $column = $self->offset;
# spent 1.08ms making 2057 calls to YAML::PP::Lexer::offset, avg 526ns/call
9092057825µs $token->{column} = $column;
91020571.08ms $token->{subtokens} = \my @sub;
911
91220574.43ms for (my $i = 0; $i < @$subtokens; $i+=3) {
91361851.43ms my $name = $subtokens->[ $i ];
91461853.39ms my $value = $subtokens->[ $i + 1 ];
91561851.55ms my $line = $subtokens->[ $i + 2 ];
916618510.6ms my $push = {
917 name => $subtokens->[ $i ],
918 line => $line,
919 column => $column,
920 };
92161853.07ms if (ref $value eq 'HASH') {
92220567.36ms %$push = ( %$push, %$value );
92320561.54ms $column += length $value->{orig};
924 }
925 else {
92641291.92ms $push->{value} = $value;
9274129875µs $column += length $value;
928 }
92961851.40ms if ($push->{name} eq 'EOL') {
930 $column = 0;
931 }
93261852.49ms push @sub, $push;
933 }
93420571.08ms $token->{line} = $sub[0]->{line};
9352057695µs push @$next, $token;
93620571.79ms20571.61ms $self->set_offset($column);
# spent 1.61ms making 2057 calls to YAML::PP::Lexer::set_offset, avg 785ns/call
93720574.70ms 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
962132µs1;
 
# spent 27.2ms within YAML::PP::Lexer::CORE:match which was called 13456 times, avg 2µs/call: # 13455 times (27.2ms+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 12µs within YAML::PP::Lexer::CORE:qr which was called 11 times, avg 1µs/call: # 4 times (3µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 750ns/call # once (4µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # 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 121 # 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 234 # once (0s+0s) by YAML::PP::Parser::BEGIN@18 at line 120 # once (0s+0s) by YAML::PP::Parser::BEGIN@18 at line 51
sub YAML::PP::Lexer::CORE:qr; # opcode
# spent 208ms within YAML::PP::Lexer::CORE:regcomp which was called 58874 times, avg 4µs/call: # 18884 times (138ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 7µs/call # 18884 times (20.7ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 1µs/call # 14054 times (42.5ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 3µs/call # 2056 times (2.39ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 1µs/call # 2056 times (1.87ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 911ns/call # 2056 times (967µs+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 470ns/call # 689 times (598µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 868ns/call # 88 times (93µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 270, avg 1µs/call # 88 times (83µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 943ns/call # 6 times (44µs+0s) by YAML::PP::Lexer::fetch_next_tokens at line 208, avg 7µs/call # 3 times (104µs+0s) by YAML::PP::Parser::BEGIN@18 at line 127, avg 35µs/call # 3 times (20µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 7µs/call # once (16µs+0s) by YAML::PP::Parser::BEGIN@18 at line 50 # once (14µs+0s) by YAML::PP::Lexer::fetch_block at line 525 # once (10µs+0s) by YAML::PP::Parser::BEGIN@18 at line 52 # once (6µs+0s) by YAML::PP::Parser::BEGIN@18 at line 121 # once (6µs+0s) by YAML::PP::Parser::BEGIN@18 at line 122 # once (6µs+0s) by YAML::PP::Parser::BEGIN@18 at line 51 # once (6µs+0s) by YAML::PP::Parser::BEGIN@18 at line 120
sub YAML::PP::Lexer::CORE:regcomp; # opcode
# spent 207ms within YAML::PP::Lexer::CORE:subst which was called 75666 times, avg 3µs/call: # 18884 times (112ms+0s) by YAML::PP::Lexer::fetch_plain at line 376, avg 6µs/call # 18884 times (29.7ms+0s) by YAML::PP::Lexer::fetch_plain at line 383, avg 2µs/call # 14054 times (27.5ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 284, avg 2µs/call # 14054 times (20.3ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 302, avg 1µs/call # 2056 times (5.48ms+0s) by YAML::PP::Lexer::fetch_quoted at line 625, avg 3µs/call # 2056 times (5.42ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 724, avg 3µs/call # 2056 times (2.39ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 741, avg 1µs/call # 2056 times (1.64ms+0s) by YAML::PP::Lexer::_read_quoted_tokens at line 727, avg 796ns/call # 689 times (1.10ms+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 329, avg 2µs/call # 689 times (795µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 331, avg 1µs/call # 88 times (51µs+0s) by YAML::PP::Lexer::_fetch_next_tokens at line 264, avg 580ns/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 (2µs+0s) by YAML::PP::Lexer::fetch_plain at line 427, avg 667ns/call # 2 times (3µs+0s) by YAML::PP::Lexer::fetch_block at line 531, avg 2µs/call # once (2µ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.