Corvus/Regex/Parse.pm

filter: Statementstmt 37.7% 193 / 512 Branchbran 26.6% 91 / 342 Conditioncond 12.1% 29 / 238 MC/DCmcdc 6.9% 9 / 129 Subroutinesub 64.4% 29 / 45 Podpod 0.0% 0 / 1 totaltotal 27.7% 351 / 1267 CC 254 SCAR 54.5
CC
254
Cov
29%
_character_escape
1122.0
_class_escape
420.0
_unicode_escape
342.0
CRAP 231.7
« Corvus/CodeGen.pm ↑ Summary Corvus/Compiler.pm »
1 package JSON::Schema::Corvus::Regex::Parse;
2  
3 # Reads an ECMA-262 pattern into a syntax tree: a port of the Go port's parse.go.
4 #
5 # A pattern is read with the grammar of the u flag, which is what JSON Schema specifies, or with the Annex B grammar of
6 # a pattern with no flag. Without the u flag a pattern is read, and a text matched, a UTF-16 code unit at a time, so a
7 # character beyond the Basic Multilingual Plane is two atoms.
8 #
9 # A node is a hash with a kind:
10 # empty matches the empty string
11 # char r one code point
12 # set set a class (JSON::Schema::Corvus::Regex::Charset)
13 # cat, alt subs a sequence, alternatives
14 # group subs => [body], group group is the number of a capturing group, from 1, or 0
15 # repeat subs => [body], min, max, lazy max is -1 for no bound
16 # bol, eol, line_start, line_end ^ and $, and the same with the m modifier
17 # wb, nwb fold \b and \B, fold inside a case-insensitive group with the u flag
18 # look subs => [body], behind, negative
19 # backref groups => [numbers], fold, name (until resolved)
20 #
21 # The limits on the size of one pattern bound the time and memory of reading and compiling it whatever it holds. A
22 # pattern over a limit dies with a too_large error, which is not the error of a pattern that is not valid.
23  
24 4 ▶use 5.026;
Subroutine BEGIN: called CC=1 SCAR=0.0
25 4 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 4 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
27 4 ▶use JSON::Schema::Corvus::Regex::Charset ();
Subroutine BEGIN: called CC=1 SCAR=0.0
28  
29 4 ▶use constant UNBOUNDED => -1;
Subroutine BEGIN: called CC=1 SCAR=0.0
30 4 ▶use constant MAX_COUNT => 2147483647;
Subroutine BEGIN: called CC=1 SCAR=0.0
31 # The longest pattern read, in bytes of UTF-8; the deepest groups; the largest size, in the bytes counted for it as it
32 # is read (NODE_SIZE for each node, RANGE_SIZE for each range a class or a case-insensitive group adds).
33 4 ▶use constant { MAX_PATTERN_LENGTH => 1 << 20, MAX_NESTING => 1000, MAX_SIZE => 1 << 20, NODE_SIZE => 32,
Subroutine BEGIN: called CC=1 SCAR=0.0
34 4 RANGE_SIZE => 8 };
35  
36 4 my $C = 'JSON::Schema::Corvus::Regex::Charset';
37  
38 # The errors: { invalid => message, at => offset } for a pattern that is not valid, and { too_large => limit,
39 # value => n } for one over a limit of size.
40 2 ▶sub _fail {
Subroutine _fail: called CC=1 SCAR=0.0
41 2 my ($p, $message) = @_;
42 2 die { invalid => $message, at => $p->{i} };
43 }
44  
45 1 ▶sub _too_large { die { too_large => $_[0], value => $_[1] } }
Subroutine _too_large: called CC=1 SCAR=0.0
46  
47 # Reads a pattern. Returns (root, parser) with the parser's needs_backtracking, or dies with an error above.
48 7 ▶sub parse {
Subroutine parse: called CC=9 SCAR=25.3
Pod undocumented
49 7 my ($pattern, $unicode) = @_;
50 7 my $bytes = $pattern;
51 7 utf8::encode($bytes);
52 7 ▶ _too_large('length', MAX_PATTERN_LENGTH) if length $bytes > MAX_PATTERN_LENGTH;
Branch: 1 branch
BranchTrueFalseTotal
if length $bytes > 1048576 1 6 7
53 6 my @cps = unpack 'W*', $pattern;
54 6 ▶ @cps = map { $_ > 0xFFFF ? (0xD800 + (($_ - 0x10000) >> 10), 0xDC00 + (($_ - 0x10000) & 0x3FF)) : $_ } @cps
Branch: 2 branches
BranchTrueFalseTotal
unless $unicode 1 5 6
$_ > 65535 ? : 0 1 1
55 unless $unicode;
56 6 ▶ my $p = bless {
Branch: 1 branch
BranchTrueFalseTotal
$unicode ? : 5 1 6
57 p => \@cps, i => 0, unicode => $unicode ? 1 : 0, depth => 0, group_count => 0, has_names => 0, groups => 0,
58 names => {}, named_refs => [], path => [], disjunctions => 0, icase => 0, multiline => 0, dot_all => 0,
59 needs_backtracking => 0, size => 0,
60 }, __PACKAGE__;
61 6 $p->_scan_groups;
62 6 my $root = $p->_disjunction;
63 4 ▶ if ($p->{i} < @cps) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"i"} < @cps) 0 4 4
64 0 ▶ $p->_fail("unmatched ')'") if $cps[ $p->{i} ] == 0x29;
Branch: 1 branch
BranchTrueFalseTotal
if $cps[$p->{"i"}] == 41 0 0 0
65 0 $p->_fail('unexpected character');
66 }
67 4 for my $ref (@{ $p->{named_refs} }) {
68 0 ▶ my $named = $p->{names}{ $ref->{name} } or $p->_fail('reference to an unknown group name');
Branch: 1 branch
BranchTrueFalseTotal
my $named = $p->{"names"}{$ref->{"name"}} or $p->_fail("reference to an unknown group name") 0 0 0
69 0 push @{ $ref->{groups} }, map { $_->[0] } @$named;
70 }
71 4 return ($root, $p);
72 }
73  
74 35 ▶sub _charge {
Subroutine _charge: called CC=2 SCAR=7.1
75 35 my ($p, $bytes) = @_;
76 35 $p->{size} += $bytes;
77 35 ▶ _too_large('size', MAX_SIZE) if $p->{size} > MAX_SIZE;
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"size"} > 1048576 0 35 35
78 }
79  
80 # Counts the capturing groups and notes whether any is named: the meaning of \1 and \k depends on groups that may
81 # follow them.
82 6 ▶sub _scan_groups {
Subroutine _scan_groups: called CC=13 SCAR=27.3
83 6 my ($p) = @_;
84 6 my $s = $p->{p};
85 6 my $in_class = 0;
86 6 ▶ for (my $k = 0; $k < @$s; $k++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($k < @$s) 63 6 69
87 63 my $c = $s->[$k];
88 63 ▶ if ($c == 0x5C) { $k++ }
Branch: 4 branches
BranchTrueFalseTotal
if ($c == 92) { } 2 61 63
elsif ($c == 91) { } 3 58 61
elsif ($c == 93) { } 3 55 58
elsif ($c == 40 and not $in_class) { } 6 98 104
89 3 elsif ($c == 0x5B) { $in_class = 1 }
90 3 elsif ($c == 0x5D) { $in_class = 0 }
91 ▶ elsif ($c == 0x28 && !$in_class) {
Condition66%2/3
$c == 40 and not $in_class
!ll&&!rl&&r
4906
MC/DC50%1/2
$c == 40 and not $in_class
$c == 40 not $in_class
Truth table66%2/3
A and not(B)
A= $c == 40B= not $in_class
ABresult
0X0
100
111
92 6 ▶ if ($k + 1 >= @$s || $s->[$k + 1] != 0x3F) {
Branch: 2 branches
BranchTrueFalseTotal
if ($k + 1 >= @$s or $$s[$k + 1] != 63) { } 4 2 6
elsif ($k + 3 < @$s and $$s[$k + 2] == 60 and $$s[$k + 3] != 61 and $$s[$k + 3] != 33) { } 0 4 4
Condition100%3/3
$k + 1 >= @$s or $$s[$k + 1] != 63
l!l&&r!l&&!r
222
MC/DC100%2/2
$k + 1 >= @$s or $$s[$k + 1] != 63
$k + 1 >= @$s $$s[$k + 1] != 63
Truth table100%3/3
A or B
A= $k + 1 >= @$sB= $$s[$k + 1] != 63
ABresult
1X1
011
000
93 4 $p->{group_count}++;
94 }
95 ▶ elsif ($k + 3 < @$s && $s->[$k + 2] == 0x3C && $s->[$k + 3] != 0x3D && $s->[$k + 3] != 0x21) {
Condition33%3/9
$k + 3 < @$s and $$s[$k + 2] == 60 and $$s[$k + 3] != 61 and $$s[$k + 3] != 33
!ll&&!rl&&r
200
$k + 3 < @$s and $$s[$k + 2] == 60 and $$s[$k + 3] != 61
!ll&&!rl&&r
200
$k + 3 < @$s and $$s[$k + 2] == 60
!ll&&!rl&&r
020
MC/DC0%0/4
$k + 3 < @$s and $$s[$k + 2] == 60 and $$s[$k + 3] != 61 and $$s[$k + 3] != 33
$k + 3 < @$s $$s[$k + 2] == 60 $$s[$k + 3] != 61 $$s[$k + 3] != 33
Truth table20%1/5
A and B and C and D
A= $k + 3 < @$sB= $$s[$k + 2] == 60C= $$s[$k + 3] != 61D= $$s[$k + 3] != 33
ABCDresult
0XXX0
10XX0
110X0
11100
11111
96 0 $p->{group_count}++;
97 0 $p->{has_names} = 1;
98 }
99 }
100 }
101 }
102  
103 47 ▶sub _more { $_[0]{i} < @{ $_[0]{p} } }
Subroutine _more: called CC=1 SCAR=0.0
104 131 ▶sub _peek { my ($p) = @_; $p->{i} < @{ $p->{p} } ? $p->{p}[ $p->{i} ] : -1 }
Subroutine _peek: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
$p->{'i'} < @{$p->{'p'};} ? : 121 10 131
105  
106 39 ▶sub _eat {
Subroutine _eat: called CC=3 SCAR=11.0
107 39 my ($p, $c) = @_;
108 39 ▶ if ($p->{i} < @{ $p->{p} } && $p->{p}[ $p->{i} ] == $c) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"i"} < @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == $c) 12 27 39
Condition100%3/3
$p->{"i"} < @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == $c
!ll&&!rl&&r
42312
MC/DC100%2/2
$p->{"i"} < @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == $c
$p->{"i"} < @{$p->{"p"};} $p->{"p"}[$p->{"i"}] == $c
Truth table100%3/3
A and B
A= $p->{"i"} < @{$p->{"p"};}B= $p->{"p"}[$p->{"i"}] == $c
ABresult
0X0
100
111
109 12 $p->{i}++;
110 12 return 1;
111 }
112 27 return 0;
113 }
114  
115 12 ▶sub _disjunction {
Subroutine _disjunction: called CC=4 SCAR=18.3
116 12 my ($p) = @_;
117 12 ▶ _too_large('nesting', MAX_NESTING) if ++$p->{depth} > MAX_NESTING;
Branch: 1 branch
BranchTrueFalseTotal
if ++$p->{"depth"} > 1000 0 12 12
118 12 $p->{disjunctions}++;
119 12 push @{ $p->{path} }, [ $p->{disjunctions}, 0 ];
120 12 my $first = $p->_alternative;
121 10 ▶ if ($p->_peek != 0x7C) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_peek != 124) 10 0 10
122 10 pop @{ $p->{path} };
123 10 $p->{depth}--;
124 10 return $first;
125 }
126 0 my $alt = { kind => 'alt', subs => [$first] };
127 0 ▶ while ($p->_eat(0x7C)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(124)) 0 0 0
128 0 $p->_charge(NODE_SIZE);
129 0 $p->{path}[-1][1]++;
130 0 push @{ $alt->{subs} }, $p->_alternative;
131 }
132 0 pop @{ $p->{path} };
133 0 $p->{depth}--;
134 0 return $alt;
135 }
136  
137 12 ▶sub _alternative {
Subroutine _alternative: called CC=6 SCAR=17.9
138 12 my ($p) = @_;
139 12 my @terms;
140 12 ▶ while ($p->_more && $p->_peek != 0x7C && $p->_peek != 0x29) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_more and $p->_peek != 124 and $p->_peek != 41) 22 10 32
Condition83%5/6
$p->_more and $p->_peek != 124 and $p->_peek != 41
!ll&&!rl&&r
6422
$p->_more and $p->_peek != 124
!ll&&!rl&&r
6026
MC/DC66%2/3
$p->_more and $p->_peek != 124 and $p->_peek != 41
$p->_more $p->_peek != 124 $p->_peek != 41
Truth table75%3/4
A and B and C
A= $p->_moreB= $p->_peek != 124C= $p->_peek != 41
ABCresult
0XX0
10X0
1100
1111
141 22 push @terms, $p->_term;
142 }
143 10 ▶ return { kind => 'empty' } unless @terms;
Branch: 1 branch
BranchTrueFalseTotal
unless @terms 2 8 10
144 8 ▶ return $terms[0] if @terms == 1;
Branch: 1 branch
BranchTrueFalseTotal
if @terms == 1 2 6 8
145 6 return { kind => 'cat', subs => \@terms };
146 }
147  
148 # The node of one literal character: inside a case-insensitive group, the class of the characters equivalent to it.
149 3 ▶sub _char_node {
Subroutine _char_node: called CC=4 SCAR=22.3
150 3 my ($p, $c) = @_;
151 3 ▶ if ($p->{icase}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"icase"}) 0 3 3
152 my ($set) = JSON::Schema::Corvus::Regex::Charset::fold_closure(JSON::Schema::Corvus::Regex::Charset::new_set([$c, $c], 0),
153 0 $p->{unicode});
154 0 my $r = $set->{ranges};
155 0 ▶ return { kind => 'set', set => $set } if @$r != 2 || $r->[0] != $r->[1];
Branch: 1 branch
BranchTrueFalseTotal
if @$r != 2 or $r->[0] != $r->[1] 0 0 0
Condition0%0/3
@$r != 2 or $r->[0] != $r->[1]
l!l&&r!l&&!r
000
MC/DC0%0/2
@$r != 2 or $r->[0] != $r->[1]
@$r != 2 $r->[0] != $r->[1]
Truth table0%0/3
A or B
A= @$r != 2B= $r->[0] != $r->[1]
ABresult
1X1
011
000
156 }
157 3 return { kind => 'char', r => $c };
158 }
159  
160 # The node of a class: inside a case-insensitive group, with every character equivalent to one of its members.
161 0 ▶sub _set_node {
Subroutine _set_node: not called CC=2 SCAR=17.9
162 0 my ($p, $set) = @_;
163 0 ▶ $set = $p->_fold($set) if $p->{icase};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"icase"} 0 0 0
164 0 return { kind => 'set', set => $set };
165 }
166  
167 0 ▶sub _fold {
Subroutine _fold: not called CC=1 SCAR=6.9
168 0 my ($p, $set) = @_;
169 0 my ($closed, $variants) = JSON::Schema::Corvus::Regex::Charset::fold_closure($set, $p->{unicode});
170 0 $p->_charge($variants + RANGE_SIZE * @{ $closed->{ranges} } / 2);
171 0 return $closed;
172 }
173  
174 22 ▶sub _term {
Subroutine _term: called CC=21 SCAR=40.6
175 22 my ($p) = @_;
176 22 $p->_charge(2 * NODE_SIZE);
177 22 my $c = $p->_peek;
178 22 my $quantifiable = 1;
179 22 my $atom;
180 22 ▶ if ($c == 0x5E) {
Branch: 9 branches
BranchTrueFalseTotal
if ($c == 94) { } 4 18 22
elsif ($c == 36) { } 4 14 18
elsif ($c == 40) { } 6 8 14
elsif ($c == 46) { } 0 8 8
elsif ($c == 91) { } 3 5 8
elsif ($c == 92) { } 2 3 5
elsif ($c == 42 or $c == 43 or $c == 63) { } 0 3 3
elsif ($c == 123) { } 0 3 3
elsif ($c == 93 or $c == 125) { } 0 3 3
181 4 $p->{i}++;
182 4 $atom = { kind => 'bol' };
183 4 $quantifiable = 0;
184 4 ▶ if ($p->{multiline}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"multiline"}) 0 4 4
185 0 $atom->{kind} = 'line_start';
186 0 $p->{needs_backtracking} = 1;
187 }
188 }
189 elsif ($c == 0x24) {
190 4 $p->{i}++;
191 4 $atom = { kind => 'eol' };
192 4 $quantifiable = 0;
193 4 ▶ if ($p->{multiline}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"multiline"}) 0 4 4
194 0 $atom->{kind} = 'line_end';
195 0 $p->{needs_backtracking} = 1;
196 }
197 }
198 elsif ($c == 0x28) {
199 6 ($atom, $quantifiable) = $p->_group;
200 }
201 elsif ($c == 0x2E) {
202 0 $p->{i}++;
203 0 ▶ $atom = { kind => 'set', set => $p->{dot_all} ? $JSON::Schema::Corvus::Regex::Charset::ANY
Branch: 1 branch
BranchTrueFalseTotal
$p->{'dot_all'} ? : 0 0 0
204 : $JSON::Schema::Corvus::Regex::Charset::DOT };
205 }
206 elsif ($c == 0x5B) {
207 3 $atom = $p->_class;
208 }
209 elsif ($c == 0x5C) {
210 2 ($atom, $quantifiable) = $p->_atom_escape;
211 }
212 ▶ elsif ($c == 0x2A || $c == 0x2B || $c == 0x3F) {
Condition33%2/6
$c == 42 or $c == 43 or $c == 63
l!l&&r!l&&!r
003
$c == 42 or $c == 43
l!l&&r!l&&!r
003
MC/DC0%0/3
$c == 42 or $c == 43 or $c == 63
$c == 42 $c == 43 $c == 63
Truth table25%1/4
A or B or C
A= $c == 42B= $c == 43C= $c == 63
ABCresult
1XX1
01X1
0011
0000
213 0 $p->_fail('nothing to repeat');
214 }
215 elsif ($c == 0x7B) {
216 0 ▶ $p->_fail('nothing to repeat') if $p->{unicode} || $p->_looks_like_quantifier;
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} or $p->_looks_like_quantifier 0 0 0
Condition0%0/3
$p->{"unicode"} or $p->_looks_like_quantifier
l!l&&r!l&&!r
000
MC/DC0%0/2
$p->{"unicode"} or $p->_looks_like_quantifier
$p->{"unicode"} $p->_looks_like_quantifier
Truth table0%0/3
A or B
A= $p->{"unicode"}B= $p->_looks_like_quantifier
ABresult
1X1
011
000
217 0 $p->{i}++;
218 0 $atom = $p->_char_node(0x7B);
219 }
220 ▶ elsif ($c == 0x5D || $c == 0x7D) {
Condition33%1/3
$c == 93 or $c == 125
l!l&&r!l&&!r
003
MC/DC0%0/2
$c == 93 or $c == 125
$c == 93 $c == 125
Truth table33%1/3
A or B
A= $c == 93B= $c == 125
ABresult
1X1
011
000
221 0 ▶ $p->_fail('lone bracket') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
222 0 $p->{i}++;
223 0 $atom = $p->_char_node($c);
224 }
225 else {
226 3 $p->{i}++;
227 3 $atom = $p->_char_node($c);
228 }
229 20 my ($min, $max, $lazy, $ok) = $p->_quantifier;
230 20 ▶ return $atom unless $ok;
Branch: 1 branch
BranchTrueFalseTotal
unless $ok 11 9 20
231 9 ▶ $p->_fail('nothing to repeat') unless $quantifiable;
Branch: 1 branch
BranchTrueFalseTotal
unless $quantifiable 0 9 9
232 9 return { kind => 'repeat', subs => [$atom], min => $min, max => $max, lazy => $lazy };
233 }
234  
235 4 ▶sub _is_digit { $_[0] >= 0x30 && $_[0] <= 0x39 }
Subroutine _is_digit: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
$_[0] >= 48 and $_[0] <= 57 2 2 4
236  
237 # Whether the text at the current '{' reads as {n}, {n,} or {n,m}.
238 0 ▶sub _looks_like_quantifier {
Subroutine _looks_like_quantifier: not called CC=11 SCAR=48.8
239 0 my ($p) = @_;
240 0 my $s = $p->{p};
241 0 my $k = $p->{i} + 1;
242 0 my $start = $k;
243 0 ▶ $k++ while $k < @$s && _is_digit($s->[$k]);
Branch: 1 branch
BranchTrueFalseTotal
$k < @$s and _is_digit($s->[$k]) and do { ++$k } 0 0 0
Condition0%0/3
$k < @$s and _is_digit($s->[$k])
!ll&&!rl&&r
000
MC/DC0%0/2
$k < @$s and _is_digit($s->[$k])
$k < @$s _is_digit($s->[$k])
Truth table0%0/3
A and B
A= $k < @$sB= _is_digit($s->[$k])
ABresult
0X0
100
111
244 0 ▶ return 0 if $k == $start || $k >= @$s;
Branch: 1 branch
BranchTrueFalseTotal
if $k == $start or $k >= @$s 0 0 0
Condition0%0/3
$k == $start or $k >= @$s
l!l&&r!l&&!r
000
MC/DC0%0/2
$k == $start or $k >= @$s
$k == $start $k >= @$s
Truth table0%0/3
A or B
A= $k == $startB= $k >= @$s
ABresult
1X1
011
000
245 0 ▶ return 1 if $s->[$k] == 0x7D;
Branch: 1 branch
BranchTrueFalseTotal
if $s->[$k] == 125 0 0 0
246 0 ▶ return 0 if $s->[$k] != 0x2C;
Branch: 1 branch
BranchTrueFalseTotal
if $s->[$k] != 44 0 0 0
247 0 $k++;
248 0 ▶ $k++ while $k < @$s && _is_digit($s->[$k]);
Branch: 1 branch
BranchTrueFalseTotal
$k < @$s and _is_digit($s->[$k]) and do { ++$k } 0 0 0
Condition0%0/3
$k < @$s and _is_digit($s->[$k])
!ll&&!rl&&r
000
MC/DC0%0/2
$k < @$s and _is_digit($s->[$k])
$k < @$s _is_digit($s->[$k])
Truth table0%0/3
A and B
A= $k < @$sB= _is_digit($s->[$k])
ABresult
0X0
100
111
249 0 ▶ return $k < @$s && $s->[$k] == 0x7D ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$k < @$s && $s->[$k] == 125 ? : 0 0 0
Condition0%0/3
$k < @$s and $s->[$k] == 125
!ll&&!rl&&r
000
MC/DC0%0/2
$k < @$s and $s->[$k] == 125
$k < @$s $s->[$k] == 125
Truth table0%0/3
A and B
A= $k < @$sB= $s->[$k] == 125
ABresult
0X0
100
111
250 }
251  
252 # Whether the first of two runs of decimal digits is the greater number, compared as written (a count has no limit
253 # of size in the grammar, and number() stops at MAX_COUNT).
254 0 ▶sub _greater_as_written {
Subroutine _greater_as_written: not called CC=2 SCAR=17.9
255 0 my ($a, $b) = @_;
256 0 my $x = join '', map { chr } @$a;
257 0 my $y = join '', map { chr } @$b;
258 0 $x =~ s/\A0+//;
259 0 $y =~ s/\A0+//;
260 0 ▶ return length $x > length $y if length $x != length $y;
Branch: 1 branch
BranchTrueFalseTotal
if length $x != length $y 0 0 0
261 0 return $x gt $y;
262 }
263  
264 # A run of decimal digits, saturating at MAX_COUNT.
265 2 ▶sub _number {
Subroutine _number: called CC=6 SCAR=18.3
266 2 my ($p) = @_;
267 2 my $start = $p->{i};
268 2 my $v = 0;
269 2 ▶ while ($p->{i} < @{ $p->{p} } && _is_digit($p->{p}[ $p->{i} ])) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"i"} < @{$p->{"p"};} and _is_digit($p->{"p"}[$p->{"i"}])) 2 2 4
Condition66%2/3
$p->{"i"} < @{$p->{"p"};} and _is_digit($p->{"p"}[$p->{"i"}])
!ll&&!rl&&r
022
MC/DC50%1/2
$p->{"i"} < @{$p->{"p"};} and _is_digit($p->{"p"}[$p->{"i"}])
$p->{"i"} < @{$p->{"p"};} _is_digit($p->{"p"}[$p->{"i"}])
Truth table66%2/3
A and B
A= $p->{"i"} < @{$p->{"p"};}B= _is_digit($p->{"p"}[$p->{"i"}])
ABresult
0X0
100
111
270 2 ▶ if ($v < MAX_COUNT) {
Branch: 1 branch
BranchTrueFalseTotal
if ($v < 2147483647) 2 0 2
271 2 $v = $v * 10 + ($p->{p}[ $p->{i} ] - 0x30);
272 2 ▶ $v = MAX_COUNT if $v > MAX_COUNT;
Branch: 1 branch
BranchTrueFalseTotal
if $v > 2147483647 0 2 2
273 }
274 2 $p->{i}++;
275 }
276 2 ▶ $p->_fail('expected a number') if $start == $p->{i};
Branch: 1 branch
BranchTrueFalseTotal
if $start == $p->{"i"} 0 2 2
277 2 return $v;
278 }
279  
280 20 ▶sub _quantifier {
Subroutine _quantifier: called CC=10 SCAR=33.0
281 20 my ($p) = @_;
282 20 my $c = $p->_peek;
283 20 my ($min, $max);
284 20 ▶ if ($c == 0x2A) { $p->{i}++; ($min, $max) = (0, UNBOUNDED) }
Branch: 4 branches
BranchTrueFalseTotal
if ($c == 42) { } 4 16 20
elsif ($c == 43) { } 4 12 16
elsif ($c == 63) { } 1 11 12
elsif ($c == 123 and $p->_looks_like_quantifier) { } 0 11 11
285 4 elsif ($c == 0x2B) { $p->{i}++; ($min, $max) = (1, UNBOUNDED) }
286 1 elsif ($c == 0x3F) { $p->{i}++; ($min, $max) = (0, 1) }
287 ▶ elsif ($c == 0x7B && $p->_looks_like_quantifier) {
Condition33%1/3
$c == 123 and $p->_looks_like_quantifier
!ll&&!rl&&r
1100
MC/DC0%0/2
$c == 123 and $p->_looks_like_quantifier
$c == 123 $p->_looks_like_quantifier
Truth table33%1/3
A and B
A= $c == 123B= $p->_looks_like_quantifier
ABresult
0X0
100
111
288 0 $p->{i}++;
289 0 my $first = $p->{i};
290 0 $min = $p->_number;
291 0 $max = $min;
292 0 my $first_end = $p->{i};
293 0 ▶ if ($p->_eat(0x2C)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(44)) 0 0 0
294 0 ▶ if ($p->_peek == 0x7D) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_peek == 125) { } 0 0 0
295 0 $max = UNBOUNDED;
296 }
297 else {
298 0 my $second = $p->{i};
299 0 $max = $p->_number;
300 # Both counts stop at MAX_COUNT, so the numbers are compared as they are written.
301 $p->_fail('numbers out of order in quantifier') if _greater_as_written(
302 0 ▶ [ @{ $p->{p} }[ $first .. $first_end - 1 ] ], [ @{ $p->{p} }[ $second .. $p->{i} - 1 ] ]);
Branch: 1 branch
BranchTrueFalseTotal
if _greater_as_written([@{$$p{"p"};}[$first .. $first_end - 1]], [@{$$p{"p"};}[$second .. $p->{"i"} - 1]]) 0 0 0
303 }
304 }
305 0 ▶ $p->_fail('malformed quantifier') unless $p->_eat(0x7D);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(125) 0 0 0
306 }
307 else {
308 11 return (0, 0, 0, 0);
309 }
310 9 return ($min, $max, $p->_eat(0x3F), 1);
311 }
312  
313 # A group or a lookaround, and whether a quantifier may follow it.
314 6 ▶sub _group {
Subroutine _group: called CC=17 SCAR=52.4
315 6 my ($p) = @_;
316 6 $p->{i}++;
317 6 ▶ return ($p->_capture(''), 1) unless $p->_eat(0x3F);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(63) 4 2 6
318 2 ▶ if ($p->_eat(0x3A)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(58)) 2 0 2
319 2 my $body = $p->_disjunction;
320 2 $p->_close;
321 2 return ({ kind => 'group', subs => [$body], group => 0 }, 1);
322 }
323 0 my $c = $p->_peek;
324 0 ▶ return ($p->_modifier_group, 1) if $c == 0x69 || $c == 0x6D || $c == 0x73 || $c == 0x2D;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 105 or $c == 109 or $c == 115 or $c == 45 0 0 0
Condition0%0/9
$c == 105 or $c == 109 or $c == 115 or $c == 45
l!l&&r!l&&!r
000
$c == 105 or $c == 109 or $c == 115
l!l&&r!l&&!r
000
$c == 105 or $c == 109
l!l&&r!l&&!r
000
MC/DC0%0/4
$c == 105 or $c == 109 or $c == 115 or $c == 45
$c == 105 $c == 109 $c == 115 $c == 45
Truth table0%0/5
A or B or C or D
A= $c == 105B= $c == 109C= $c == 115D= $c == 45
ABCDresult
1XXX1
01XX1
001X1
00011
00000
325 0 ▶ if ($p->_eat(0x3D) || $p->_eat(0x21)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(61) or $p->_eat(33)) 0 0 0
Condition0%0/3
$p->_eat(61) or $p->_eat(33)
l!l&&r!l&&!r
000
MC/DC0%0/2
$p->_eat(61) or $p->_eat(33)
$p->_eat(61) $p->_eat(33)
Truth table0%0/3
A or B
A= $p->_eat(61)B= $p->_eat(33)
ABresult
1X1
011
000
326 0 ▶ my $negative = $p->{p}[ $p->{i} - 1 ] == 0x21 ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$p->{'p'}[$p->{'i'} - 1] == 33 ? : 0 0 0
327 0 my $body = $p->_disjunction;
328 0 $p->_close;
329 0 $p->{needs_backtracking} = 1;
330 # Annex B lets a quantifier follow a lookahead. The u flag does not.
331 0 return ({ kind => 'look', subs => [$body], negative => $negative, behind => 0 }, !$p->{unicode});
332 }
333 0 ▶ if ($p->_eat(0x3C)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(60)) 0 0 0
334 0 ▶ if ($p->_eat(0x3D) || $p->_eat(0x21)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_eat(61) or $p->_eat(33)) 0 0 0
Condition0%0/3
$p->_eat(61) or $p->_eat(33)
l!l&&r!l&&!r
000
MC/DC0%0/2
$p->_eat(61) or $p->_eat(33)
$p->_eat(61) $p->_eat(33)
Truth table0%0/3
A or B
A= $p->_eat(61)B= $p->_eat(33)
ABresult
1X1
011
000
335 0 ▶ my $negative = $p->{p}[ $p->{i} - 1 ] == 0x21 ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$p->{'p'}[$p->{'i'} - 1] == 33 ? : 0 0 0
336 0 my $body = $p->_disjunction;
337 0 $p->_close;
338 0 $p->{needs_backtracking} = 1;
339 0 return ({ kind => 'look', subs => [$body], negative => $negative, behind => 1 }, 0);
340 }
341 0 my $name = $p->_group_name;
342 # Two groups may share a name only when they are in separate alternatives of one disjunction, so that no match can
343 # go through both.
344 0 ▶ for my $other (@{ $p->{names}{$name} // [] }) {
Condition0%0/2
$p->{"names"}{$name} // []
l!l
00
MC/DC0%0/1
$p->{"names"}{$name} // []
$p->{"names"}{$name}
Truth table0%0/2
A
A= $p->{"names"}{$name}
Aresult
11
00
345 0 ▶ $p->_fail('duplicate group name') unless _separate_alternatives($other->[1], $p->{path});
Branch: 1 branch
BranchTrueFalseTotal
unless _separate_alternatives($other->[1], $p->{"path"}) 0 0 0
346 }
347 0 return ($p->_capture($name), 1);
348 }
349 0 $p->_fail('invalid group');
350 }
351  
352 # Whether two positions lie in different alternatives of some disjunction.
353 0 ▶sub _separate_alternatives {
Subroutine _separate_alternatives: not called CC=5 SCAR=34.0
354 0 my ($a, $b) = @_;
355 0 ▶ for (my $i = 0; $i < @$a && $i < @$b && $a->[$i][0] == $b->[$i][0]; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @$a and $i < @$b and $a->[$i][0] == $b->[$i][0]) 0 0 0
Condition0%0/6
$i < @$a and $i < @$b and $a->[$i][0] == $b->[$i][0]
!ll&&!rl&&r
000
$i < @$a and $i < @$b
!ll&&!rl&&r
000
MC/DC0%0/3
$i < @$a and $i < @$b and $a->[$i][0] == $b->[$i][0]
$i < @$a $i < @$b $a->[$i][0] == $b->[$i][0]
Truth table0%0/4
A and B and C
A= $i < @$aB= $i < @$bC= $a->[$i][0] == $b->[$i][0]
ABCresult
0XX0
10X0
1100
1111
356 0 ▶ return 1 if $a->[$i][1] != $b->[$i][1];
Branch: 1 branch
BranchTrueFalseTotal
if $a->[$i][1] != $b->[$i][1] 0 0 0
357 }
358 0 return 0;
359 }
360  
361 # A group that turns modifiers on or off for its body, such as (?i:...) or (?s-i:...). The position is after the "(?".
362 0 ▶sub _modifier_group {
Subroutine _modifier_group: not called CC=10 SCAR=47.0
363 0 my ($p) = @_;
364 0 my @saved = @$p{qw(icase multiline dot_all)};
365 0 my %seen;
366 0 my ($removing, $count) = (0, 0);
367 0 ▶ until ($p->_eat(0x3A)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->_eat(58)) 0 0 0
368 0 my $c = $p->_peek;
369 0 $p->{i}++;
370 0 my $flag;
371 0 ▶ if ($c == 0x69) { $flag = 'icase' }
Branch: 4 branches
BranchTrueFalseTotal
if ($c == 105) { } 0 0 0
elsif ($c == 109) { } 0 0 0
elsif ($c == 115) { } 0 0 0
elsif ($c == 45) { } 0 0 0
372 0 elsif ($c == 0x6D) { $flag = 'multiline' }
373 0 elsif ($c == 0x73) { $flag = 'dot_all' }
374 elsif ($c == 0x2D) {
375 0 ▶ $p->_fail('invalid group modifier') if $removing;
Branch: 1 branch
BranchTrueFalseTotal
if $removing 0 0 0
376 0 $removing = 1;
377 0 next;
378 }
379 else {
380 0 $p->_fail('invalid group modifier');
381 }
382 0 ▶ $p->_fail('repeated group modifier') if $seen{$flag}++;
Branch: 1 branch
BranchTrueFalseTotal
if $seen{$flag}++ 0 0 0
383 0 ▶ $p->{$flag} = $removing ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$removing ? : 0 0 0
384 0 $count++;
385 }
386 0 ▶ $p->_fail('invalid group modifier') if $count == 0;
Branch: 1 branch
BranchTrueFalseTotal
if $count == 0 0 0 0
387 0 my $body = $p->_disjunction;
388 0 $p->_close;
389 0 @$p{qw(icase multiline dot_all)} = @saved;
390 0 return { kind => 'group', subs => [$body], group => 0 };
391 }
392  
393 4 ▶sub _capture {
Subroutine _capture: called CC=3 SCAR=15.8
394 4 my ($p, $name) = @_;
395 4 my $g = { kind => 'group', group => ++$p->{groups} };
396 4 ▶ if (length $name) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $name) 0 4 4
397 # The path is kept, and every group of the same name is compared with it.
398 0 ▶ $p->_charge(RANGE_SIZE * (@{ $p->{path} } + @{ $p->{names}{$name} // [] }));
Condition0%0/2
$p->{"names"}{$name} // []
l!l
00
MC/DC0%0/1
$p->{"names"}{$name} // []
$p->{"names"}{$name}
Truth table0%0/2
A
A= $p->{"names"}{$name}
Aresult
11
00
399 0 push @{ $p->{names}{$name} }, [ $g->{group}, [ map { [@$_] } @{ $p->{path} } ] ];
400 }
401 4 $g->{subs} = [ $p->_disjunction ];
402 4 $p->_close;
403 2 return $g;
404 }
405  
406 6 ▶sub _close { $_[0]->_fail('unterminated group') unless $_[0]->_eat(0x29) }
Subroutine _close: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
unless $_[0]->_eat(41) 2 4 6
407  
408 # A group name up to and including its '>'. A character of the name may be written as a \u escape.
409 0 ▶sub _group_name {
Subroutine _group_name: not called CC=19 SCAR=58.1
410 0 my ($p) = @_;
411 0 my @name;
412 0 ▶ until ($p->_eat(0x3E)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->_eat(62)) 0 0 0
413 0 ▶ $p->_fail('invalid group name') unless $p->_more;
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_more 0 0 0
414 0 my $c = $p->_peek;
415 0 $p->{i}++;
416 0 ▶ if ($c == 0x5C) {
Branch: 2 branches
BranchTrueFalseTotal
if ($c == 92) { } 0 0 0
elsif ($c >= 55296 and $c <= 56319 and $p->_peek >= 56320 and $p->_peek <= 57343) { } 0 0 0
417 0 ▶ $p->_fail('invalid group name') unless $p->_eat(0x75);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(117) 0 0 0
418 0 $c = $p->_unicode_escape(1);
419 0 ▶ $p->_fail('invalid group name') if $c < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $c < 0 0 0 0
420 }
421 ▶ elsif ($c >= 0xD800 && $c <= 0xDBFF && $p->_peek >= 0xDC00 && $p->_peek <= 0xDFFF) {
Condition0%0/9
$c >= 55296 and $c <= 56319 and $p->_peek >= 56320 and $p->_peek <= 57343
!ll&&!rl&&r
000
$c >= 55296 and $c <= 56319 and $p->_peek >= 56320
!ll&&!rl&&r
000
$c >= 55296 and $c <= 56319
!ll&&!rl&&r
000
MC/DC0%0/4
$c >= 55296 and $c <= 56319 and $p->_peek >= 56320 and $p->_peek <= 57343
$c >= 55296 $c <= 56319 $p->_peek >= 56320 $p->_peek <= 57343
Truth table0%0/5
A and B and C and D
A= $c >= 55296B= $c <= 56319C= $p->_peek >= 56320D= $p->_peek <= 57343
ABCDresult
0XXX0
10XX0
110X0
11100
11111
422 # Without the u flag the pattern is code units, and a name still takes a surrogate pair as one character.
423 0 $c = 0x10000 + (($c - 0xD800) << 10) + ($p->_peek - 0xDC00);
424 0 $p->{i}++;
425 }
426 0 ▶ if (!@name) {
Branch: 1 branch
BranchTrueFalseTotal
if (not @name) { } 0 0 0
427 0 ▶ $p->_fail('invalid group name') unless $c == 0x24 || $c == 0x5F || _id_start($c);
Branch: 1 branch
BranchTrueFalseTotal
unless $c == 36 or $c == 95 or _id_start($c) 0 0 0
Condition0%0/6
$c == 36 or $c == 95 or _id_start($c)
l!l&&r!l&&!r
000
$c == 36 or $c == 95
l!l&&r!l&&!r
000
MC/DC0%0/3
$c == 36 or $c == 95 or _id_start($c)
$c == 36 $c == 95 _id_start($c)
Truth table0%0/4
A or B or C
A= $c == 36B= $c == 95C= _id_start($c)
ABCresult
1XX1
01X1
0011
0000
428 }
429 else {
430 0 ▶ $p->_fail('invalid group name') unless $c == 0x24 || $c == 0x200C || $c == 0x200D || _id_continue($c);
Branch: 1 branch
BranchTrueFalseTotal
unless $c == 36 or $c == 8204 or $c == 8205 or _id_continue($c) 0 0 0
Condition0%0/9
$c == 36 or $c == 8204 or $c == 8205 or _id_continue($c)
l!l&&r!l&&!r
000
$c == 36 or $c == 8204 or $c == 8205
l!l&&r!l&&!r
000
$c == 36 or $c == 8204
l!l&&r!l&&!r
000
MC/DC0%0/4
$c == 36 or $c == 8204 or $c == 8205 or _id_continue($c)
$c == 36 $c == 8204 $c == 8205 _id_continue($c)
Truth table0%0/5
A or B or C or D
A= $c == 36B= $c == 8204C= $c == 8205D= _id_continue($c)
ABCDresult
1XXX1
01XX1
001X1
00011
00000
431 }
432 0 push @name, $c;
433 }
434 0 ▶ $p->_fail('invalid group name') unless @name;
Branch: 1 branch
BranchTrueFalseTotal
unless @name 0 0 0
435 4 ▶ no warnings qw(surrogate nonchar non_unicode);
Subroutine BEGIN: called CC=1 SCAR=0.0
436 0 return join '', map { chr } @name;
437 }
438  
439 4 my ($ID_START, $ID_CONTINUE);
440 0 ▶sub _id_start { ($ID_START //= JSON::Schema::Corvus::Regex::Charset::property_set('ID_Start'))->contains($_[0]) }
Subroutine _id_start: not called CC=2 SCAR=17.9
Condition0%0/3
$ID_START //= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Start")
l!l&&r!l&&!r
000
MC/DC0%0/2
$ID_START //= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Start")
$ID_START JSON::Schema::Corvus::Regex::Charset::property_set("ID_Start")
Truth table0%0/3
A //= B
A= $ID_STARTB= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Start")
ABresult
1X1
011
000
441 0 ▶sub _id_continue {
Subroutine _id_continue: not called CC=2 SCAR=17.9
442 0 ▶ ($ID_CONTINUE //= JSON::Schema::Corvus::Regex::Charset::property_set('ID_Continue'))->contains($_[0]);
Condition0%0/3
$ID_CONTINUE //= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Continue")
l!l&&r!l&&!r
000
MC/DC0%0/2
$ID_CONTINUE //= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Continue")
$ID_CONTINUE JSON::Schema::Corvus::Regex::Charset::property_set("ID_Continue")
Truth table0%0/3
A //= B
A= $ID_CONTINUEB= JSON::Schema::Corvus::Regex::Charset::property_set("ID_Continue")
ABresult
1X1
011
000
443 }
444  
445 # An escape outside a class, and whether a quantifier may follow it.
446 2 ▶sub _atom_escape {
Subroutine _atom_escape: called CC=16 SCAR=47.2
447 2 my ($p) = @_;
448 2 $p->{i}++;
449 2 ▶ $p->_fail('\\ at end of pattern') unless $p->_more;
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_more 0 2 2
450 2 my $c = $p->_peek;
451 2 ▶ if ($c == 0x62 || $c == 0x42) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 98 or $c == 66) 0 2 2
Condition33%1/3
$c == 98 or $c == 66
l!l&&r!l&&!r
002
MC/DC0%0/2
$c == 98 or $c == 66
$c == 98 $c == 66
Truth table33%1/3
A or B
A= $c == 98B= $c == 66
ABresult
1X1
011
000
452 0 $p->{i}++;
453 0 ▶ my $boundary = { kind => $c == 0x42 ? 'nwb' : 'wb', fold => 0 };
Branch: 1 branch
BranchTrueFalseTotal
$c == 66 ? : 0 0 0
454 # With the u flag, a case-insensitive word boundary counts two more characters as word characters.
455 0 ▶ if ($p->{unicode} && $p->{icase}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"unicode"} and $p->{"icase"}) 0 0 0
Condition0%0/3
$p->{"unicode"} and $p->{"icase"}
!ll&&!rl&&r
000
MC/DC0%0/2
$p->{"unicode"} and $p->{"icase"}
$p->{"unicode"} $p->{"icase"}
Truth table0%0/3
A and B
A= $p->{"unicode"}B= $p->{"icase"}
ABresult
0X0
100
111
456 0 $boundary->{fold} = 1;
457 0 $p->{needs_backtracking} = 1;
458 }
459 0 return ($boundary, 0);
460 }
461 2 ▶ if ($c == 0x6B) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 107) 0 2 2
462 # Annex B reads \k as the letter k in a pattern with no named group.
463 0 ▶ if ($p->{unicode} || $p->{has_names}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"unicode"} or $p->{"has_names"}) 0 0 0
Condition0%0/3
$p->{"unicode"} or $p->{"has_names"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$p->{"unicode"} or $p->{"has_names"}
$p->{"unicode"} $p->{"has_names"}
Truth table0%0/3
A or B
A= $p->{"unicode"}B= $p->{"has_names"}
ABresult
1X1
011
000
464 0 $p->{i}++;
465 0 ▶ $p->_fail('invalid named reference') unless $p->_eat(0x3C);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(60) 0 0 0
466 0 my $ref = { kind => 'backref', name => $p->_group_name, fold => $p->{icase}, groups => [] };
467 0 push @{ $p->{named_refs} }, $ref;
468 0 $p->{needs_backtracking} = 1;
469 0 return ($ref, 1);
470 }
471 0 $p->{i}++;
472 0 return ($p->_char_node(0x6B), 1);
473 }
474 2 ▶ if ($c >= 0x31 && $c <= 0x39) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c >= 49 and $c <= 57) 2 0 2
Condition33%1/3
$c >= 49 and $c <= 57
!ll&&!rl&&r
002
MC/DC0%0/2
$c >= 49 and $c <= 57
$c >= 49 $c <= 57
Truth table33%1/3
A and B
A= $c >= 49B= $c <= 57
ABresult
0X0
100
111
475 2 my $start = $p->{i};
476 2 my $n = $p->_number;
477 2 ▶ if ($n <= $p->{group_count}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($n <= $p->{"group_count"}) 2 0 2
478 2 $p->{needs_backtracking} = 1;
479 2 return ({ kind => 'backref', groups => [$n], fold => $p->{icase} }, 1);
480 }
481 0 ▶ $p->_fail('reference to a group that does not exist') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
482 # Annex B reads it as an octal escape, or as the digit itself.
483 0 $p->{i} = $start;
484 0 return ($p->_char_node($p->_legacy_octal), 1);
485 }
486 0 ▶ if (my $set = $p->_class_escape($c)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $set = $p->_class_escape($c)) 0 0 0
487 0 return ($p->_set_node($set), 1);
488 }
489 0 return ($p->_char_node($p->_character_escape(0)), 1);
490 }
491  
492 # An Annex B octal escape of up to three digits with a value below 256. A digit that cannot start one (8 or 9) stands
493 # for itself.
494 0 ▶sub _legacy_octal {
Subroutine _legacy_octal: not called CC=7 SCAR=40.3
495 0 my ($p) = @_;
496 0 my ($v, $k) = (0, 0);
497 0 ▶ while ($k < 3 && $p->_more && $p->_peek >= 0x30 && $p->_peek <= 0x37 && $v * 8 + ($p->_peek - 0x30) <= 0377) {
Branch: 1 branch
BranchTrueFalseTotal
if ($k < 3 and $p->_more and $p->_peek >= 48 and $p->_peek <= 55 and $v * 8 + ($p->_peek - 48) <= 255) 0 0 0
Condition0%0/12
$k < 3 and $p->_more and $p->_peek >= 48 and $p->_peek <= 55 and $v * 8 + ($p->_peek - 48) <= 255
!ll&&!rl&&r
000
$k < 3 and $p->_more and $p->_peek >= 48 and $p->_peek <= 55
!ll&&!rl&&r
000
$k < 3 and $p->_more and $p->_peek >= 48
!ll&&!rl&&r
000
$k < 3 and $p->_more
!ll&&!rl&&r
000
MC/DC0%0/5
$k < 3 and $p->_more and $p->_peek >= 48 and $p->_peek <= 55 and $v * 8 + ($p->_peek - 48) <= 255
$k < 3 $p->_more $p->_peek >= 48 $p->_peek <= 55 $v * 8 + ($p->_peek - 48) <= 255
Truth table0%0/6
A and B and C and D and E
A= $k < 3B= $p->_moreC= $p->_peek >= 48D= $p->_peek <= 55E= $v * 8 + ($p->_peek - 48) <= 255
ABCDEresult
0XXXX0
10XXX0
110XX0
1110X0
111100
111111
498 0 $v = $v * 8 + ($p->_peek - 0x30);
499 0 $p->{i}++;
500 0 $k++;
501 }
502 0 ▶ if ($k == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($k == 0) 0 0 0
503 0 my $d = $p->_peek;
504 0 $p->{i}++;
505 0 return $d;
506 }
507 0 return $v;
508 }
509  
510 # A class escape such as \d or \p{...} whose letter is c, or undef, consuming nothing, when c does not start one.
511 0 ▶sub _class_escape {
Subroutine _class_escape: not called CC=20 SCAR=60.4
512 0 my ($p, $c) = @_;
513 0 ▶ if ($c == 0x64) { $p->{i}++; return $JSON::Schema::Corvus::Regex::Charset::DIGIT }
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 100) 0 0 0
514 0 ▶ if ($c == 0x44) { $p->{i}++; return $JSON::Schema::Corvus::Regex::Charset::NOT_DIGIT }
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 68) 0 0 0
515 0 ▶ if ($c == 0x77) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 119) 0 0 0
516 0 $p->{i}++;
517 0 ▶ return $p->{unicode} && $p->{icase} ? $JSON::Schema::Corvus::Regex::Charset::FOLD_WORD
Branch: 1 branch
BranchTrueFalseTotal
$p->{'unicode'} && $p->{'icase'} ? : 0 0 0
Condition0%0/3
$p->{"unicode"} and $p->{"icase"}
!ll&&!rl&&r
000
MC/DC0%0/2
$p->{"unicode"} and $p->{"icase"}
$p->{"unicode"} $p->{"icase"}
Truth table0%0/3
A and B
A= $p->{"unicode"}B= $p->{"icase"}
ABresult
0X0
100
111
518 : $JSON::Schema::Corvus::Regex::Charset::WORD;
519 }
520 0 ▶ if ($c == 0x57) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 87) 0 0 0
521 0 $p->{i}++;
522 0 ▶ return $p->{unicode} && $p->{icase} ? $JSON::Schema::Corvus::Regex::Charset::NOT_FOLD_WORD
Branch: 1 branch
BranchTrueFalseTotal
$p->{'unicode'} && $p->{'icase'} ? : 0 0 0
Condition0%0/3
$p->{"unicode"} and $p->{"icase"}
!ll&&!rl&&r
000
MC/DC0%0/2
$p->{"unicode"} and $p->{"icase"}
$p->{"unicode"} $p->{"icase"}
Truth table0%0/3
A and B
A= $p->{"unicode"}B= $p->{"icase"}
ABresult
0X0
100
111
523 : $JSON::Schema::Corvus::Regex::Charset::NOT_WORD;
524 }
525 0 ▶ if ($c == 0x73) { $p->{i}++; return $JSON::Schema::Corvus::Regex::Charset::SPACE }
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 115) 0 0 0
526 0 ▶ if ($c == 0x53) { $p->{i}++; return $JSON::Schema::Corvus::Regex::Charset::NOT_SPACE }
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 83) 0 0 0
527 0 ▶ if ($c == 0x70 || $c == 0x50) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 112 or $c == 80) 0 0 0
Condition0%0/3
$c == 112 or $c == 80
l!l&&r!l&&!r
000
MC/DC0%0/2
$c == 112 or $c == 80
$c == 112 $c == 80
Truth table0%0/3
A or B
A= $c == 112B= $c == 80
ABresult
1X1
011
000
528 # Without the u flag \p is the letter p.
529 0 ▶ return undef unless $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"unicode"} 0 0 0
530 0 $p->{i}++;
531 0 ▶ $p->_fail('invalid property name') unless $p->_eat(0x7B);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(123) 0 0 0
532 0 my $start = $p->{i};
533 0 ▶ $p->{i}++ while $p->_more && $p->_peek != 0x7D;
Branch: 1 branch
BranchTrueFalseTotal
$p->_more and $p->_peek != 125 and do { ++$p->{"i"} } 0 0 0
Condition0%0/3
$p->_more and $p->_peek != 125
!ll&&!rl&&r
000
MC/DC0%0/2
$p->_more and $p->_peek != 125
$p->_more $p->_peek != 125
Truth table0%0/3
A and B
A= $p->_moreB= $p->_peek != 125
ABresult
0X0
100
111
534 0 my $expr = join '', map { chr } @{ $p->{p} }[ $start .. $p->{i} - 1 ];
535 0 ▶ $p->_fail('invalid property name') unless $p->_eat(0x7D);
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_eat(125) 0 0 0
536 0 ▶ my $set = JSON::Schema::Corvus::Regex::Charset::property_set($expr) or $p->_fail('invalid property name');
Branch: 1 branch
BranchTrueFalseTotal
my $set = JSON::Schema::Corvus::Regex::Charset::property_set($expr) or $p->_fail("invalid property name") 0 0 0
537 0 ▶ if ($c == 0x50) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 80) 0 0 0
538 0 $p->_charge(RANGE_SIZE * @{ $set->{ranges} } / 2);
539 0 return JSON::Schema::Corvus::Regex::Charset::new_set($set->{ranges}, 1);
540 }
541 0 return $set;
542 }
543 0 return undef;
544 }
545  
546 0 ▶sub _hex_value {
Subroutine _hex_value: not called CC=7 SCAR=40.3
547 0 my ($c) = @_;
548 0 ▶ return $c - 0x30 if $c >= 0x30 && $c <= 0x39;
Branch: 1 branch
BranchTrueFalseTotal
if $c >= 48 and $c <= 57 0 0 0
Condition0%0/3
$c >= 48 and $c <= 57
!ll&&!rl&&r
000
MC/DC0%0/2
$c >= 48 and $c <= 57
$c >= 48 $c <= 57
Truth table0%0/3
A and B
A= $c >= 48B= $c <= 57
ABresult
0X0
100
111
549 0 ▶ return $c - 0x61 + 10 if $c >= 0x61 && $c <= 0x66;
Branch: 1 branch
BranchTrueFalseTotal
if $c >= 97 and $c <= 102 0 0 0
Condition0%0/3
$c >= 97 and $c <= 102
!ll&&!rl&&r
000
MC/DC0%0/2
$c >= 97 and $c <= 102
$c >= 97 $c <= 102
Truth table0%0/3
A and B
A= $c >= 97B= $c <= 102
ABresult
0X0
100
111
550 0 ▶ return $c - 0x41 + 10 if $c >= 0x41 && $c <= 0x46;
Branch: 1 branch
BranchTrueFalseTotal
if $c >= 65 and $c <= 70 0 0 0
Condition0%0/3
$c >= 65 and $c <= 70
!ll&&!rl&&r
000
MC/DC0%0/2
$c >= 65 and $c <= 70
$c >= 65 $c <= 70
Truth table0%0/3
A and B
A= $c >= 65B= $c <= 70
ABresult
0X0
100
111
551 0 return -1;
552 }
553  
554 # Exactly n hexadecimal digits, or -1, consuming nothing, when they are not there.
555 0 ▶sub _hex {
Subroutine _hex: not called CC=4 SCAR=30.0
556 0 my ($p, $n) = @_;
557 0 ▶ return -1 if $p->{i} + $n > @{ $p->{p} };
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"i"} + $n > @{$p->{"p"};} 0 0 0
558 0 my $v = 0;
559 0 for my $k (0 .. $n - 1) {
560 0 my $d = _hex_value($p->{p}[ $p->{i} + $k ]);
561 0 ▶ return -1 if $d < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $d < 0 0 0 0
562 0 $v = $v * 16 + $d;
563 }
564 0 $p->{i} += $n;
565 0 return $v;
566 }
567  
568 0 ▶sub _is_ascii_letter { ($_[0] >= 0x61 && $_[0] <= 0x7A) || ($_[0] >= 0x41 && $_[0] <= 0x5A) }
Subroutine _is_ascii_letter: not called CC=4 SCAR=30.0
Branch: 1 branch
BranchTrueFalseTotal
$_[0] >= 97 and $_[0] <= 122 or $_[0] >= 65 and $_[0] <= 90 0 0 0
Condition0%0/9
$_[0] >= 97 && $_[0] <= 122 || $_[0] >= 65 && $_[0] <= 90
l!l&&r!l&&!r
000
$_[0] >= 97 and $_[0] <= 122
!ll&&!rl&&r
000
$_[0] >= 65 and $_[0] <= 90
!ll&&!rl&&r
000
MC/DC0%0/4
$_[0] >= 97 && $_[0] <= 122 || $_[0] >= 65 && $_[0] <= 90
$_[0] >= 97 $_[0] <= 122 $_[0] >= 65 $_[0] <= 90
Truth table0%0/7
A and B || C and D
A= $_[0] >= 97B= $_[0] <= 122C= $_[0] >= 65D= $_[0] <= 90
ABCDresult
11XX1
0X111
10111
0X0X0
0X100
100X0
10100
569  
570 # The characters the u flag lets an identity escape name.
571 4 my %SYNTAX = map { ord($_) => 1 } split //, '^$\\.*+?()[]{}|/';
572  
573 # The escape after a backslash, in or out of a class: the code point it names.
574 0 ▶sub _character_escape {
Subroutine _character_escape: not called CC=33 SCAR=70.2
575 0 my ($p, $in_class) = @_;
576 0 my $c = $p->_peek;
577 0 $p->{i}++;
578 0 ▶ return 0x0C if $c == 0x66;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 102 0 0 0
579 0 ▶ return 0x0A if $c == 0x6E;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 110 0 0 0
580 0 ▶ return 0x0D if $c == 0x72;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 114 0 0 0
581 0 ▶ return 0x09 if $c == 0x74;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 116 0 0 0
582 0 ▶ return 0x0B if $c == 0x76;
Branch: 1 branch
BranchTrueFalseTotal
if $c == 118 0 0 0
583 0 ▶ if ($c == 0x63) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 99) 0 0 0
584 0 my $l = $p->_peek;
585 0 ▶ if (_is_ascii_letter($l)) {
Branch: 1 branch
BranchTrueFalseTotal
if (_is_ascii_letter($l)) 0 0 0
586 0 $p->{i}++;
587 0 return $l % 32;
588 }
589 0 ▶ if (!$p->{unicode} && $in_class && (_is_digit($l) || $l == 0x5F)) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $p->{"unicode"} and $in_class and _is_digit($l) || $l == 95) 0 0 0
Condition0%0/9
not $p->{"unicode"} and $in_class and _is_digit($l) || $l == 95
!ll&&!rl&&r
000
not $p->{"unicode"} and $in_class
!ll&&!rl&&r
000
_is_digit($l) or $l == 95
l!l&&r!l&&!r
000
MC/DC0%0/4
not $p->{"unicode"} and $in_class and _is_digit($l) || $l == 95
not $p->{"unicode"} $in_class _is_digit($l) $l == 95
Truth table0%0/5
not(A) and B and C or D
A= not $p->{"unicode"}B= $in_classC= _is_digit($l)D= $l == 95
ABCDresult
0XXX0
10XX0
11000
111X1
11011
590 0 $p->{i}++;
591 0 return $l % 32;
592 }
593 0 ▶ $p->_fail('invalid control escape') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
594 # Annex B reads a \c that is not a control escape as a backslash followed by the letter c.
595 0 $p->{i}--;
596 0 return 0x5C;
597 }
598 0 ▶ if ($c == 0x30) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 48) 0 0 0
599 0 ▶ if ($p->_more && _is_digit($p->_peek)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_more and _is_digit($p->_peek)) 0 0 0
Condition0%0/3
$p->_more and _is_digit($p->_peek)
!ll&&!rl&&r
000
MC/DC0%0/2
$p->_more and _is_digit($p->_peek)
$p->_more _is_digit($p->_peek)
Truth table0%0/3
A and B
A= $p->_moreB= _is_digit($p->_peek)
ABresult
0X0
100
111
600 0 ▶ $p->_fail('invalid decimal escape') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
601 0 $p->{i}--;
602 0 return $p->_legacy_octal;
603 }
604 0 return 0;
605 }
606 0 ▶ if ($c == 0x78) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 120) 0 0 0
607 0 my $h = $p->_hex(2);
608 0 ▶ if ($h < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($h < 0) 0 0 0
609 0 ▶ $p->_fail('invalid \\x escape') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
610 0 return 0x78;
611 }
612 0 return $h;
613 }
614 0 ▶ if ($c == 0x75) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c == 117) 0 0 0
615 0 my $u = $p->_unicode_escape($p->{unicode});
616 0 ▶ if ($u < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($u < 0) 0 0 0
617 0 ▶ $p->_fail('invalid \\u escape') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
618 0 return 0x75;
619 }
620 0 return $u;
621 }
622 0 ▶ if ($c >= 0x31 && $c <= 0x39 && !$p->{unicode} && $in_class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c >= 49 and $c <= 57 and not $p->{"unicode"} and $in_class) 0 0 0
Condition0%0/9
$c >= 49 and $c <= 57 and not $p->{"unicode"} and $in_class
!ll&&!rl&&r
000
$c >= 49 and $c <= 57 and not $p->{"unicode"}
!ll&&!rl&&r
000
$c >= 49 and $c <= 57
!ll&&!rl&&r
000
MC/DC0%0/4
$c >= 49 and $c <= 57 and not $p->{"unicode"} and $in_class
$c >= 49 $c <= 57 not $p->{"unicode"} $in_class
Truth table0%0/5
A and B and not(C) and D
A= $c >= 49B= $c <= 57C= not $p->{"unicode"}D= $in_class
ABCDresult
0XXX0
10XX0
110X0
11100
11111
623 0 $p->{i}--;
624 0 return $p->_legacy_octal;
625 }
626 # Identity escapes. The u flag allows only the syntax characters and '/', and '-' in a class. Annex B allows any
627 # character, except k in a pattern with a named group.
628 0 ▶ $p->_fail('invalid escape') if $p->{unicode} && !$SYNTAX{$c} && !($in_class && $c == 0x2D);
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} and not $SYNTAX{$c} and not $in_class && $c == 45 0 0 0
Condition0%0/9
$p->{"unicode"} and not $SYNTAX{$c} and not $in_class && $c == 45
!ll&&!rl&&r
000
$p->{"unicode"} and not $SYNTAX{$c}
!ll&&!rl&&r
000
$in_class && $c == 45
!ll&&!rl&&r
000
MC/DC0%0/4
$p->{"unicode"} and not $SYNTAX{$c} and not $in_class && $c == 45
$p->{"unicode"} not $SYNTAX{$c} $in_class $c == 45
Truth table0%0/5
A and not(B) and not(C && D)
A= $p->{"unicode"}B= not $SYNTAX{$c}C= $in_classD= $c == 45
ABCDresult
0XXX0
10XX0
11110
110X1
11101
629 0 ▶ $p->_fail('invalid escape') if $c == 0x6B && $p->{has_names};
Branch: 1 branch
BranchTrueFalseTotal
if $c == 107 and $p->{"has_names"} 0 0 0
Condition0%0/3
$c == 107 and $p->{"has_names"}
!ll&&!rl&&r
000
MC/DC0%0/2
$c == 107 and $p->{"has_names"}
$c == 107 $p->{"has_names"}
Truth table0%0/3
A and B
A= $c == 107B= $p->{"has_names"}
ABresult
0X0
100
111
630 0 return $c;
631 }
632  
633 # What follows a \u: the code point, or -1, consuming nothing, when it is not a well-formed escape. In unicode mode (the
634 # u flag, and always in a group name) the \u{...} form is read, and a surrogate pair written as two escapes is one code
635 # point.
636 0 ▶sub _unicode_escape {
Subroutine _unicode_escape: not called CC=18 SCAR=58.3
637 0 my ($p, $unicode_mode) = @_;
638 0 my $start = $p->{i};
639 0 ▶ if ($unicode_mode && $p->_eat(0x7B)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($unicode_mode and $p->_eat(123)) 0 0 0
Condition0%0/3
$unicode_mode and $p->_eat(123)
!ll&&!rl&&r
000
MC/DC0%0/2
$unicode_mode and $p->_eat(123)
$unicode_mode $p->_eat(123)
Truth table0%0/3
A and B
A= $unicode_modeB= $p->_eat(123)
ABresult
0X0
100
111
640 0 my $digits = $p->{i};
641 0 my $v = 0;
642 0 ▶ while ($p->_more && _hex_value($p->_peek) >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_more and _hex_value($p->_peek) >= 0) 0 0 0
Condition0%0/3
$p->_more and _hex_value($p->_peek) >= 0
!ll&&!rl&&r
000
MC/DC0%0/2
$p->_more and _hex_value($p->_peek) >= 0
$p->_more _hex_value($p->_peek) >= 0
Truth table0%0/3
A and B
A= $p->_moreB= _hex_value($p->_peek) >= 0
ABresult
0X0
100
111
643 0 ▶ $v = $v * 16 + _hex_value($p->_peek) if $v <= 0x10FFFF;
Branch: 1 branch
BranchTrueFalseTotal
if $v <= 1114111 0 0 0
644 0 $p->{i}++;
645 }
646 0 ▶ if ($digits == $p->{i} || !$p->_eat(0x7D) || $v > 0x10FFFF) {
Branch: 1 branch
BranchTrueFalseTotal
if ($digits == $p->{"i"} or not $p->_eat(125) or $v > 1114111) 0 0 0
Condition0%0/6
$digits == $p->{"i"} or not $p->_eat(125) or $v > 1114111
l!l&&r!l&&!r
000
$digits == $p->{"i"} or not $p->_eat(125)
l!l&&r!l&&!r
000
MC/DC0%0/3
$digits == $p->{"i"} or not $p->_eat(125) or $v > 1114111
$digits == $p->{"i"} not $p->_eat(125) $v > 1114111
Truth table0%0/4
A or not(B) or C
A= $digits == $p->{"i"}B= not $p->_eat(125)C= $v > 1114111
ABCresult
1XX1
01X1
0011
0000
647 0 $p->{i} = $start;
648 0 return -1;
649 }
650 0 return $v;
651 }
652 0 my $u = $p->_hex(4);
653 0 ▶ return -1 if $u < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $u < 0 0 0 0
654 0 ▶ if ($unicode_mode && $u >= 0xD800 && $u <= 0xDBFF && $p->{i} + 6 <= @{ $p->{p} } && $p->{p}[ $p->{i} ] == 0x5C
Branch: 1 branch
BranchTrueFalseTotal
if ($unicode_mode and $u >= 55296 and $u <= 56319 and $p->{"i"} + 6 <= @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == 92 and $p->{"p"}[$p->{"i"} + 1] == 117) 0 0 0
Condition0%0/15
$unicode_mode and $u >= 55296 and $u <= 56319 and $p->{"i"} + 6 <= @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == 92 and $p->{"p"}[$p->{"i"} + 1] == 117
!ll&&!rl&&r
000
$unicode_mode and $u >= 55296 and $u <= 56319 and $p->{"i"} + 6 <= @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == 92
!ll&&!rl&&r
000
$unicode_mode and $u >= 55296 and $u <= 56319 and $p->{"i"} + 6 <= @{$p->{"p"};}
!ll&&!rl&&r
000
$unicode_mode and $u >= 55296 and $u <= 56319
!ll&&!rl&&r
000
$unicode_mode and $u >= 55296
!ll&&!rl&&r
000
MC/DC0%0/6
$unicode_mode and $u >= 55296 and $u <= 56319 and $p->{"i"} + 6 <= @{$p->{"p"};} and $p->{"p"}[$p->{"i"}] == 92 and $p->{"p"}[$p->{"i"} + 1] == 117
$unicode_mode $u >= 55296 $u <= 56319 $p->{"i"} + 6 <= @{$p->{"p"};} $p->{"p"}[$p->{"i"}] == 92 $p->{"p"}[$p->{"i"} + 1] == 117
Truth table0%0/7
A and B and C and D and E and F
A= $unicode_modeB= $u >= 55296C= $u <= 56319D= $p->{"i"} + 6 <= @{$p->{"p"};}E= $p->{"p"}[$p->{"i"}] == 92F= $p->{"p"}[$p->{"i"} + 1] == 117
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
11110X0
1111100
1111111
655 && $p->{p}[ $p->{i} + 1 ] == 0x75) {
656 0 my $save = $p->{i};
657 0 $p->{i} += 2;
658 0 my $low = $p->_hex(4);
659 0 ▶ return 0x10000 + (($u - 0xD800) << 10) + ($low - 0xDC00) if $low >= 0xDC00 && $low <= 0xDFFF;
Branch: 1 branch
BranchTrueFalseTotal
if $low >= 56320 and $low <= 57343 0 0 0
Condition0%0/3
$low >= 56320 and $low <= 57343
!ll&&!rl&&r
000
MC/DC0%0/2
$low >= 56320 and $low <= 57343
$low >= 56320 $low <= 57343
Truth table0%0/3
A and B
A= $low >= 56320B= $low <= 57343
ABresult
0X0
100
111
660 0 $p->{i} = $save;
661 }
662 0 return $u;
663 }
664  
665 # A character class from its '[' to its ']'.
666 3 ▶sub _class {
Subroutine _class: called CC=15 SCAR=32.4
667 3 my ($p) = @_;
668 3 $p->{i}++;
669 3 my $negated = $p->_eat(0x5E);
670 3 my @pairs;
671 3 my $charged = 0;
672 3 while (1) {
673 13 ▶ $p->_fail('unterminated character class') unless $p->_more;
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_more 0 13 13
674 13 ▶ last if $p->_eat(0x5D);
Branch: 1 branch
BranchTrueFalseTotal
if $p->_eat(93) 3 10 13
675 10 $p->_charge(RANGE_SIZE * (@pairs / 2 - $charged));
676 10 $charged = @pairs / 2;
677 10 my ($first, $first_set) = $p->_class_atom;
678 10 ▶ if ($p->_peek == 0x2D && $p->{i} + 1 < @{ $p->{p} } && $p->{p}[ $p->{i} + 1 ] != 0x5D) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->_peek == 45 and $p->{"i"} + 1 < @{$p->{"p"};} and $p->{"p"}[$p->{"i"} + 1] != 93) 5 5 10
Condition66%4/6
$p->_peek == 45 and $p->{"i"} + 1 < @{$p->{"p"};} and $p->{"p"}[$p->{"i"} + 1] != 93
!ll&&!rl&&r
505
$p->_peek == 45 and $p->{"i"} + 1 < @{$p->{"p"};}
!ll&&!rl&&r
505
MC/DC33%1/3
$p->_peek == 45 and $p->{"i"} + 1 < @{$p->{"p"};} and $p->{"p"}[$p->{"i"} + 1] != 93
$p->_peek == 45 $p->{"i"} + 1 < @{$p->{"p"};} $p->{"p"}[$p->{"i"} + 1] != 93
Truth table50%2/4
A and B and C
A= $p->_peek == 45B= $p->{"i"} + 1 < @{$p->{"p"};}C= $p->{"p"}[$p->{"i"} + 1] != 93
ABCresult
0XX0
10X0
1100
1111
679 5 $p->{i}++;
680 5 my ($second, $second_set) = $p->_class_atom;
681 5 ▶ if ($first_set || $second_set) {
Branch: 1 branch
BranchTrueFalseTotal
if ($first_set or $second_set) 0 5 5
Condition33%1/3
$first_set or $second_set
l!l&&r!l&&!r
005
MC/DC0%0/2
$first_set or $second_set
$first_set $second_set
Truth table33%1/3
A or B
A= $first_setB= $second_set
ABresult
1X1
011
000
682 0 ▶ $p->_fail('invalid character class range') if $p->{unicode};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"unicode"} 0 0 0
683 # Annex B reads the '-' as itself when a class escape is at either end.
684 0 ▶ push @pairs, $first_set ? @{ $first_set->{ranges} } : ($first, $first);
Branch: 1 branch
BranchTrueFalseTotal
$first_set ? : 0 0 0
685 0 push @pairs, 0x2D, 0x2D;
686 0 ▶ push @pairs, $second_set ? @{ $second_set->{ranges} } : ($second, $second);
Branch: 1 branch
BranchTrueFalseTotal
$second_set ? : 0 0 0
687 0 next;
688 }
689 5 ▶ $p->_fail('range out of order in character class') if $second < $first;
Branch: 1 branch
BranchTrueFalseTotal
if $second < $first 0 5 5
690 5 push @pairs, $first, $second;
691 5 next;
692 }
693 0 ▶ push @pairs, $first_set ? @{ $first_set->{ranges} } : ($first, $first);
Branch: 1 branch
BranchTrueFalseTotal
$first_set ? : 0 5 5
694 }
695 # Inside a case-insensitive group a character matches the class when it is equivalent to a member, and a negated
696 # class excludes exactly those characters.
697 3 $p->_charge(RANGE_SIZE * (@pairs / 2 - $charged));
698 3 my $set = JSON::Schema::Corvus::Regex::Charset::new_set(\@pairs, 0);
699 3 ▶ $set = $p->_fold($set) if $p->{icase};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"icase"} 0 3 3
700 3 ▶ $set = JSON::Schema::Corvus::Regex::Charset::new_set($set->{ranges}, 1) if $negated;
Branch: 1 branch
BranchTrueFalseTotal
if $negated 1 2 3
701 3 return { kind => 'set', set => $set };
702 }
703  
704 # One member of a class: a code point, or (0, set) for a class escape.
705 15 ▶sub _class_atom {
Subroutine _class_atom: called CC=5 SCAR=27.4
706 15 my ($p) = @_;
707 15 my $c = $p->_peek;
708 15 $p->{i}++;
709 15 ▶ return ($c, undef) if $c != 0x5C;
Branch: 1 branch
BranchTrueFalseTotal
if $c != 92 15 0 15
710 0 ▶ $p->_fail('\\ at end of pattern') unless $p->_more;
Branch: 1 branch
BranchTrueFalseTotal
unless $p->_more 0 0 0
711 0 my $e = $p->_peek;
712 0 ▶ if ($e == 0x62) {
Branch: 1 branch
BranchTrueFalseTotal
if ($e == 98) 0 0 0
713 0 $p->{i}++;
714 0 return (0x08, undef);
715 }
716 0 ▶ if (my $set = $p->_class_escape($e)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $set = $p->_class_escape($e)) 0 0 0
717 0 return (0, $set);
718 }
719 0 return ($p->_character_escape(1), undef);
720 }
721  
722 4 1;
« Corvus/CodeGen.pm ↑ Summary Corvus/Compiler.pm »