R3/MetaAST.pm

filter: Statementstmt 88.7% 1014 / 1142 Branchbran 70.0% 217 / 310 Conditioncond 67.9% 87 / 128 MC/DCmcdc 35.8% 29 / 81 Subroutinesub 93.8% 107 / 114 Podpod n/a totaltotal 81.9% 1454 / 1775 CC 242 SCAR 36.1
CC
242
Cov
83%
evaluate
122.4
evaluate
63.6
evaluate
40.9
CRAP 37.1
« R3/Glade.pm ↑ Summary R3/X.pm »
1 # Marpa::R3 is Copyright (C) 2018, Jeffrey Kegler.
2 #
3 # This module is free software; you can redistribute it and/or modify it
4 # under the same terms as Perl 5.10.1. For more details, see the full text
5 # of the licenses in the directory LICENSES.
6 #
7 # This program is distributed in the hope that it will be
8 # useful, but it is provided "as is" and without any express
9 # or implied warranties. For details, see the full text of
10 # of the licenses in the directory LICENSES.
11  
12 package Marpa::R3::MetaAST;
13  
14 104 ▶use 5.010001;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 104 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 104 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
17  
18 104 ▶use vars qw($VERSION $STRING_VERSION);
Subroutine BEGIN: called CC=1 SCAR=0.0
19 104 $VERSION = '4.001_054';
20 104 $STRING_VERSION = $VERSION;
21 ## no critic(BuiltinFunctions::ProhibitStringyEval)
22 104 $VERSION = eval $VERSION;
23 ## use critic
24  
25 package Marpa::R3::Internal::MetaAST;
26  
27 104 ▶use English qw( -no_match_vars );
Subroutine BEGIN: called CC=1 SCAR=0.0
28  
29 292 ▶sub new {
Subroutine new: called CC=4 SCAR=13.9
30 292 my ( $class, $p_rules_source ) = @_;
31 292 my $meta_recce = Marpa::R3::Internal::meta_recce();
32 292 my $valuer;
33 292 ▶ eval { $meta_recce->read($p_rules_source) }
Branch: 1 branch
BranchTrueFalseTotal
eval { do { $meta_recce->read($p_rules_source) } } or Marpa::R3::exception("Parse of BNF/Scanless source failed\n", $Marpa::R3::Internal::MetaAST::EVAL_ERROR) 290 2 292
34 or Marpa::R3::exception( "Parse of BNF/Scanless source failed\n",
35 $EVAL_ERROR );
36 290 $valuer = Marpa::R3::Valuer->new( { recognizer => $meta_recce } );
37 290 my $ambiguity_level = $valuer->ambiguity_level();
38 290 ▶ if ( $ambiguity_level != 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ambiguity_level != 1) 1 289 290
39 1 my $ambiguity_status = $valuer->ambiguous();
40 1 Marpa::R3::exception( "Parse of BNF/Scanless source failed:\n",
41 $ambiguity_status );
42 }
43 289 my $value_ref = $valuer->value();
44 289 ▶ Marpa::R3::exception('Parse of BNF/Scanless source failed')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value_ref 0 289 289
45 if not defined $value_ref;
46 289 my $ast = { meta_recce => $meta_recce, top_node => ${$value_ref} };
47 289 return bless $ast, $class;
48 }
49  
50 18 ▶sub Marpa::R3::Internal::MetaAST::Parse::substring {
Subroutine substring: called CC=1 SCAR=0.0
51 18 my ( $parse, $start, $length ) = @_;
52 18 my $meta_slr = $parse->{meta_recce};
53 18 my ($block_id) = $meta_slr->block_progress();
54 18 my $string = $meta_slr->literal( $block_id, $start, $length );
55 18 chomp $string;
56 18 return $string;
57 } ## end sub Marpa::R3::Internal::MetaAST::Parse::substring
58  
59 0 ▶sub Marpa::R3::Internal::MetaAST::Parse::line_column {
Subroutine line_column: not called CC=1 SCAR=6.9
60 0 my ( $parse, $pos ) = @_;
61 0 return Marpa::R3::Internal::line_column($parse->{p_dsl}, $pos);
62 }
63  
64 # Assign symbols, creating "ordinary" symbols if no symbol
65 # already exists
66 7310 ▶sub Marpa::R3::Internal::MetaAST::Parse::symbol_assign_ordinary {
Subroutine symbol_assign_ordinary: called CC=2 SCAR=6.9
67 7310 my ( $parse, $symbol_name, $subg ) = @_;
68 7310 my $wsym = $parse->{symbols}->{$subg}->{$symbol_name};
69 7310 ▶ return $wsym if $wsym;
Branch: 1 branch
BranchTrueFalseTotal
if $wsym 5024 2286 7310
70 # say STDERR "symbol_assign_ordinary($symbol_name, $subg)";
71 2286 my $symbol_data = {
72 dsl_form => $symbol_name,
73 name_source => 'lexical'
74 };
75 2286 $parse->xsy_assign( $symbol_name, $symbol_data );
76 2286 $symbol_data = { xsy => $symbol_name };
77 2286 $parse->symbol_names_set( $symbol_name, $subg,
78 $symbol_data );
79 }
80  
81 289 ▶sub ast_to_hash {
Subroutine ast_to_hash: called CC=26 SCAR=32.6
82 289 my ($ast, $p_dsl) = @_;
83 289 my $xpr_ordinal = 0;
84 289 my $hashed_ast = {};
85  
86 289 $hashed_ast->{meta_recce} = $ast->{meta_recce};
87 289 bless $hashed_ast, 'Marpa::R3::Internal::MetaAST::Parse';
88  
89 289 $hashed_ast->{p_dsl} = $p_dsl;
90 289 $hashed_ast->{xpr}->{l0} = {};
91 289 $hashed_ast->{xpr}->{g1} = {};
92 289 $hashed_ast->{rules}->{l0} = [];
93 289 $hashed_ast->{rules}->{g1} = [];
94 289 $hashed_ast->{lexeme_declarations} = {};
95 289 my $declarations = $hashed_ast->{lexeme_declarations};
96 289 my $g1_symbols = $hashed_ast->{symbols}->{g1} = {};
97  
98 289 my ( undef, undef, @statements ) = @{ $ast->{top_node} };
99  
100 # This is the last ditch exception catcher
101 # It forces all Marpa exceptions to be die's,
102 # then catches them and rethrows using Carp.
103 #
104 # The plan is to use die(), with higher levels
105 # catching and re-die()'ing after adding
106 # helpful location information. After the
107 # re-throw it is caught here and passed to
108 # Carp.
109 289 my $eval_ok = eval {
110 289 local $Marpa::R3::JUST_DIE = 1;
111 289 $_->evaluate($hashed_ast) for @statements;
112 284 1;
113 };
114 289 ▶ Marpa::R3::exception($EVAL_ERROR) if not $eval_ok;
Branch: 1 branch
BranchTrueFalseTotal
unless $eval_ok 5 284 289
115  
116 # Add the G1 augment rule
117 {
118 284 my $start_lhs = $hashed_ast->{'start_lhs'}
119 284 ▶ // $hashed_ast->{'first_lhs'};
Condition66%2/3
$hashed_ast->{"start_lhs"} // $hashed_ast->{"first_lhs"}
l!l&&r!l&&!r
1141700
MC/DC0%0/2
$hashed_ast->{"start_lhs"} // $hashed_ast->{"first_lhs"}
$hashed_ast->{"start_lhs"} $hashed_ast->{"first_lhs"}
Truth table66%2/3
A // B
A= $hashed_ast->{"start_lhs"}B= $hashed_ast->{"first_lhs"}
ABresult
1X1
011
000
120 284 ▶ Marpa::R3::exception('No rules in SLIF grammar')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $start_lhs 0 284 284
121 if not defined $start_lhs;
122 284 my $augment_lhs = '[:start:]';
123 284 my $symbol_data = {
124 dsl_form => $augment_lhs,
125 name_source => 'internal',
126 };
127 284 $hashed_ast->xsy_create( $augment_lhs, $symbol_data );
128 284 $hashed_ast->symbol_names_set( $augment_lhs, 'g1', { xsy => $augment_lhs } );
129  
130 284 my $rule_data = {
131 start => 0,
132 length => 0,
133 lhs => $augment_lhs,
134 rhs => [$start_lhs],
135 subkey => $xpr_ordinal++,
136 action => '::first'
137 };
138 284 $hashed_ast->symbol_assign_ordinary($start_lhs, 'g1');
139 284 my $wrl = $hashed_ast->xpr_create( $rule_data, 'g1' );
140 284 push @{ $hashed_ast->{rules}->{g1} }, $wrl;
141 }
142  
143 # If the lexer is empty, create a fake one
144 # The fake lexer contains one rule.
145 # This rule discards everything it matches, but it
146 # never matches anything.
147 284 ▶ if ( not %{ $hashed_ast->{xpr}->{l0} } ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (%{$hashed_ast->{"xpr"}{"l0"};}) 5 279 284
148  
149 # the unicorn is a pattern which never matches
150 5 my $unicorn_class = '[[^\\d\\D]]';
151 5 my $unicorn;
152 {
153 5 local $Marpa::R3::Internal::SUBGRAMMAR = 'l0';
154 5 my $unicorn_symbol =
155 Marpa::R3::Internal::MetaAST::Symbol_List->char_class_to_symbol(
156 $hashed_ast, $unicorn_class );
157 5 $unicorn = $unicorn_symbol->name();
158 };
159 5 my $discard_lhs = '[:discard:]';
160 5 my $symbol_data = {
161 dsl_form => $discard_lhs,
162 name_source => 'internal',
163 };
164 5 $hashed_ast->xsy_assign( $discard_lhs, $symbol_data );
165 5 $hashed_ast->symbol_names_set( $discard_lhs, 'l0',
166 { xsy => $discard_lhs } );
167 5 my $rule_data = {
168 start => 0,
169 length => 0,
170 lhs => $discard_lhs,
171 rhs => [$unicorn],
172 symbol_as_event => $unicorn,
173 subkey => $xpr_ordinal++,
174  
175 # 'description' => 'Discard rule for <[[^\\d\\D]]>'
176 };
177 5 my $wrl = $hashed_ast->xpr_create( $rule_data, 'l0' );
178 5 push @{ $hashed_ast->{rules}->{l0} }, $wrl;
179 }
180  
181 # Add the L0 augment rule
182 284 if (1) {
183 # Target symbol assumed to exist already
184 284 my $target_lhs = '[:target:]';
185 284 ▶ Marpa::R3::exception('No rules in SLIF L0 grammar')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $target_lhs 0 284 284
186 if not defined $target_lhs;
187 284 my $augment_lhs = '[:lex_start:]';
188 284 my $symbol_data = {
189 dsl_form => $augment_lhs,
190 name_source => 'internal',
191 };
192 284 $hashed_ast->xsy_create( $augment_lhs, $symbol_data );
193 284 $hashed_ast->symbol_names_set( $augment_lhs, 'l0', { xsy => $augment_lhs } );
194  
195 284 my $rule_data = {
196 start => 0,
197 length => 0,
198 lhs => $augment_lhs,
199 rhs => [$target_lhs],
200 };
201 284 $hashed_ast->symbol_assign_ordinary($target_lhs, 'l0');
202 284 my $wrl = $hashed_ast->xpr_create( $rule_data, 'l0' );
203 284 push @{ $hashed_ast->{rules}->{l0} }, $wrl;
204 }
205  
206 284 my %l0_lhs = ();
207 284 my %l0_rhs = ();
208 284 RULE: for my $rule (values %{$hashed_ast->{xpr}->{l0}}) {
209 1796 my $lhs = $rule->{lhs};
210 1796 $l0_lhs{$lhs} = 1;
211 1796 $l0_rhs{$_} = 1 for @{$rule->{rhs}};
212 1796 my $separator = $rule->{separator};
213 1796 ▶ $l0_rhs{$separator} = 1 if $separator;
Branch: 1 branch
BranchTrueFalseTotal
if $separator 0 1796 1796
214 }
215 284 my %g1_lhs = ();
216 284 my %g1_rhs = ();
217 284 RULE: for my $rule (values %{$hashed_ast->{xpr}->{g1}}) {
218 1539 my $lhs = $rule->{lhs};
219 1539 $g1_lhs{$lhs} = 1;
220 1539 $g1_rhs{$_} = 1 for @{$rule->{rhs}};
221 1539 my $separator = $rule->{separator};
222 1539 ▶ $g1_rhs{$separator} = 1 if $separator;
Branch: 1 branch
BranchTrueFalseTotal
if $separator 19 1520 1539
223 }
224  
225  
226 284 my %lexeme = ();
227 284 $lexeme{$_} = 'a lexeme in L0' for grep { not $l0_rhs{$_} } keys %l0_lhs;
228 284 $lexeme{$_} = 'a lexeme in G1' for grep { not $g1_lhs{$_} } keys %g1_rhs;
229 284 $lexeme{$_} = 'a declared lexeme' for keys %{$declarations};
230 284 LEXEME: for my $lexeme ( sort keys %lexeme ) {
231 1181 ▶ next LEXEME if $lexeme eq '[:lex_start:]';
Branch: 1 branch
BranchTrueFalseTotal
if $lexeme eq "[:lex_start:]" 276 905 1181
232 905 ▶ $declarations->{$lexeme} //= {};
Condition100%2/2
$declarations->{$lexeme} //= {}
l!l
89816
MC/DC100%1/1
$declarations->{$lexeme} //= {}
$declarations->{$lexeme}
Truth table100%2/2
A
A= $declarations->{$lexeme}
Aresult
11
00
233 905 ▶ if ( $lexeme ne '[:discard:]' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($lexeme ne "[:discard:]") 745 160 905
234 745 ▶ if ( not $l0_lhs{$lexeme} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($l0_lhs{$lexeme}) 2 743 745
235 2 my $type = $lexeme{$lexeme};
236 2 Marpa::R3::exception(
237 "<$lexeme> is $type, but is not on the LHS of any L0 rule\n",
238 " A lexeme must be the LHS of some L0 rule\n"
239 );
240 }
241 743 ▶ if ( $l0_rhs{$lexeme} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($l0_rhs{$lexeme}) 2 741 743
242 2 my $type = $lexeme{$lexeme};
243 2 Marpa::R3::exception(
244 "<$lexeme> is $type, but is on the RHS of an L0 rule\n",
245 " A lexeme must not be in the RHS of any L0 rule\n"
246 );
247 }
248 741 ▶ if ( $g1_lhs{$lexeme} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($g1_lhs{$lexeme}) 2 739 741
249 2 my $type = $lexeme{$lexeme};
250 2 Marpa::R3::exception(
251 "<$lexeme> is $type, but is on the LHS of a G1 rule\n",
252 " A lexeme cannot be the LHS of any G1 rule\n"
253 );
254 }
255 739 ▶ if ( not $g1_rhs{$lexeme} and $lexeme ne '[:lex_start:]') {
Branch: 1 branch
BranchTrueFalseTotal
if (not $g1_rhs{$lexeme} and $lexeme ne "[:lex_start:]") 2 737 739
Condition66%2/3
not $g1_rhs{$lexeme} and $lexeme ne "[:lex_start:]"
!ll&&!rl&&r
73702
MC/DC50%1/2
not $g1_rhs{$lexeme} and $lexeme ne "[:lex_start:]"
not $g1_rhs{$lexeme} $lexeme ne "[:lex_start:]"
Truth table66%2/3
not(A) and B
A= not $g1_rhs{$lexeme}B= $lexeme ne "[:lex_start:]"
ABresult
0X0
100
111
256 2 my $type = $lexeme{$lexeme};
257 2 Marpa::R3::exception(
258 "<$lexeme> is $type, but is not on the RHS of any G1 rule\n",
259 " A lexeme must be in the RHS of at least one G1 rule\n"
260 );
261 }
262 }
263  
264 {
265 897 my $target_lhs = '[:target:]';
266 897 my $symbol_data = {
267 dsl_form => $target_lhs,
268 name_source => 'internal',
269 };
270 897 $hashed_ast->xsy_assign( $target_lhs, $symbol_data );
271 897 $hashed_ast->symbol_names_set( $target_lhs, 'l0',
272 { xsy => $target_lhs } );
273  
274 897 my $rule_data = {
275 start => 0,
276 length => 0,
277 lhs => $target_lhs,
278 rhs => [$lexeme],
279 };
280 897 $hashed_ast->symbol_assign_ordinary( $target_lhs, 'l0' );
281 897 my $wrl = $hashed_ast->xpr_create( $rule_data, 'l0' );
282 897 push @{ $hashed_ast->{rules}->{l0} }, $wrl;
283 }
284 }
285  
286 276 my %stripped_character_classes = ();
287 {
288 276 my $character_classes = $hashed_ast->{character_classes};
289 276 for my $symbol_name ( sort keys %{$character_classes} ) {
290 1319 my ($re) = @{ $character_classes->{$symbol_name} };
291 1319 $stripped_character_classes{$symbol_name} = $re;
292 }
293 }
294 276 $hashed_ast->{character_classes} = \%stripped_character_classes;
295  
296 # say STDERR Data::Dumper::Dumper($hashed_ast);
297  
298 276 return $hashed_ast;
299 } ## end sub ast_to_hash
300  
301 # This class is for pieces of RHS alternatives, as they are
302 # being constructed
303 104 my $PROTO_ALTERNATIVE = 'Marpa::R3::Internal::MetaAST::Proto_Alternative';
304  
305 823 ▶sub Marpa::R3::Internal::MetaAST::Proto_Alternative::combine {
Subroutine combine: called CC=4 SCAR=13.9
306 823 my ( $class, @hashes ) = @_;
307 823 my $self = bless {}, $class;
308 823 for my $hash_to_add (@hashes) {
309 943 for my $key ( keys %{$hash_to_add} ) {
310 ## expect to be caught and rethrown
311 die qq{A Marpa rule contained a duplicate key\n},
312 qq{ The key was "$key"\n}
313 937 ▶ if exists $self->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if exists $self->{$key} 0 937 937
314 937 $self->{$key} = $hash_to_add->{$key};
315 } ## end for my $key ( keys %{$hash_to_add} )
316 } ## end for my $hash_to_add (@hashes)
317 823 return $self;
318 } ## end sub Marpa::R3::Internal::MetaAST::Proto_Alternative::combine
319  
320 2225 ▶sub Marpa::R3::Internal::MetaAST::Parse::bless_hash_rule {
Subroutine bless_hash_rule: called CC=8 SCAR=21.6
321 2225 my ( $parse, $hash_rule, $blessing, $naming, $original_lhs ) = @_;
322 2225 ▶ return if (substr $Marpa::R3::Internal::SUBGRAMMAR, 0, 1) eq 'l0';
Branch: 1 branch
BranchTrueFalseTotal
if substr($Marpa::R3::Internal::SUBGRAMMAR, 0, 1) eq "l0" 0 2225 2225
323  
324 2225 ▶ $naming //= $original_lhs;
Condition66%2/3
$naming //= $original_lhs
l!l&&r!l&&!r
1022150
MC/DC0%0/2
$naming //= $original_lhs
$naming $original_lhs
Truth table66%2/3
A //= B
A= $namingB= $original_lhs
ABresult
1X1
011
000
325 2225 $hash_rule->{name} = $naming;
326  
327 2225 ▶ return if not defined $blessing;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $blessing 2095 130 2225
328 FIND_BLESSING: {
329 130 ▶ last FIND_BLESSING if $blessing =~ /\A [\w] /xms;
Branch: 1 branch
BranchTrueFalseTotal
if $blessing =~ /\A [\w] /msx 102 28 130
330 28 ▶ return if $blessing eq '::undef';
Branch: 1 branch
BranchTrueFalseTotal
if $blessing eq "::undef" 0 28 28
331  
332 # Rule may be half-formed, but assume we have lhs
333 28 ▶ if ( $blessing eq '::lhs' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessing eq "::lhs") 28 0 28
334 28 $blessing = $original_lhs;
335 28 ▶ if ( $blessing =~ / [^ [:alnum:]] /xms ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessing =~ / [^ [:alnum:]] /msx) 0 28 28
336 0 Marpa::R3::exception(
337 qq{"::lhs" blessing only allowed if LHS is whitespace and alphanumerics\n},
338 qq{ LHS was <$original_lhs>\n}
339 );
340 } ## end if ( $blessing =~ / [^ [:alnum:]] /xms )
341 28 $blessing =~ s/[ ]/_/gxms;
342 28 last FIND_BLESSING;
343 } ## end if ( $blessing eq '::lhs' )
344 0 Marpa::R3::exception( qq{Unknown blessing "$blessing"\n} );
345 } ## end FIND_BLESSING:
346 130 $hash_rule->{bless} = $blessing;
347 130 return 1;
348 } ## end sub Marpa::R3::Internal::MetaAST::Parse::bless_hash_rule
349  
350 4083 ▶sub Marpa::R3::Internal::MetaAST_Nodes::bare_name::name { return $_[0]->[2] }
Subroutine name: called CC=1 SCAR=0.0
351  
352 110 ▶sub Marpa::R3::Internal::MetaAST_Nodes::reserved_action_name::name {
Subroutine name: called CC=1 SCAR=0.0
353 110 my ( $self, $parse ) = @_;
354 110 return $self->[2];
355 }
356  
357 33 ▶sub Marpa::R3::Internal::MetaAST_Nodes::reserved_event_name::name {
Subroutine name: called CC=1 SCAR=0.0
358 33 my ( $self, $parse ) = @_;
359 33 my $name = $self->[2];
360 33 $name =~ s/\A : /'/xms;
361 33 return $name;
362 }
363  
364 490 ▶sub Marpa::R3::Internal::MetaAST_Nodes::action_name::name {
Subroutine name: called CC=1 SCAR=0.0
365 490 my ( $self, $parse ) = @_;
366 490 return $self->[2]->name($parse);
367 }
368  
369 10 ▶sub Marpa::R3::Internal::MetaAST_Nodes::alternative_name::name {
Subroutine name: called CC=1 SCAR=0.0
370 10 my ( $self, $parse ) = @_;
371 10 return $self->[2]->name($parse);
372 }
373  
374 300 ▶sub Marpa::R3::Internal::MetaAST_Nodes::event_name::name {
Subroutine name: called CC=1 SCAR=0.0
375 300 my ( $self, $parse ) = @_;
376 300 return $self->[2]->name($parse);
377 }
378  
379 119 ▶sub Marpa::R3::Internal::MetaAST_Nodes::array_descriptor::name {
Subroutine name: called CC=1 SCAR=0.0
380 119 return $_[0]->[2];
381 }
382  
383 17 ▶sub Marpa::R3::Internal::MetaAST_Nodes::reserved_blessing_name::name {
Subroutine name: called CC=1 SCAR=0.0
384 17 return $_[0]->[2];
385 }
386  
387 119 ▶sub Marpa::R3::Internal::MetaAST_Nodes::blessing_name::name {
Subroutine name: called CC=1 SCAR=0.0
388 119 my ( $self, $parse ) = @_;
389 119 return $self->[2]->name($parse);
390 }
391  
392 163 ▶sub Marpa::R3::Internal::MetaAST_Nodes::standard_name::name {
Subroutine name: called CC=1 SCAR=0.0
393 163 return $_[0]->[2];
394 }
395  
396 261 ▶sub Marpa::R3::Internal::MetaAST_Nodes::Perl_name::name {
Subroutine name: called CC=1 SCAR=0.0
397 261 return $_[0]->[2];
398 }
399  
400 1866 ▶sub Marpa::R3::Internal::MetaAST_Nodes::lhs::name {
Subroutine name: called CC=1 SCAR=0.0
401 1866 my ( $values, $parse ) = @_;
402 1866 my ( undef, undef, $symbol ) = @{$values};
403 1866 return $symbol->name($parse);
404 }
405  
406 # After development, delete this
407 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::lhs::evaluate {
Subroutine evaluate: not called CC=1 SCAR=6.9
408 0 my ( $values, $parse ) = @_;
409 0 return $values->name($parse);
410 }
411  
412 322 ▶sub Marpa::R3::Internal::MetaAST_Nodes::quantifier::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
413 322 my ($data) = @_;
414 322 return $data->[2];
415 }
416  
417 1866 ▶sub Marpa::R3::Internal::MetaAST_Nodes::op_declare::op {
Subroutine op: called CC=1 SCAR=0.0
418 1866 my ($values) = @_;
419 1866 return $values->[2]->op();
420 }
421  
422 910 ▶sub Marpa::R3::Internal::MetaAST_Nodes::op_declare_match::op {
Subroutine op: called CC=1 SCAR=0.0
423 910 my ($values) = @_;
424 910 return $values->[2];
425 }
426  
427 1095 ▶sub Marpa::R3::Internal::MetaAST_Nodes::op_declare_bnf::op {
Subroutine op: called CC=1 SCAR=0.0
428 1095 my ($values) = @_;
429 1095 return $values->[2];
430 }
431  
432 581 ▶sub Marpa::R3::Internal::MetaAST_Nodes::bracketed_name::name {
Subroutine name: called CC=1 SCAR=0.0
433 581 my ($values) = @_;
434 581 my ( undef, undef, $bracketed_name ) = @{$values};
435  
436 # normalize whitespace
437 581 $bracketed_name =~ s/\A [<] \s*//xms;
438 581 $bracketed_name =~ s/ \s* [>] \z//xms;
439 581 $bracketed_name =~ s/ \s+ / /gxms;
440 581 return $bracketed_name;
441 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::bracketed_name::name
442  
443 216 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_quoted_name::name {
Subroutine name: called CC=1 SCAR=0.0
444 216 my ($values) = @_;
445 216 my ( undef, undef, $single_quoted_name ) = @{$values};
446  
447 # normalize whitespace
448 216 $single_quoted_name =~ s/\A ['] \s*//xms;
449 216 $single_quoted_name =~ s/ \s* ['] \z//xms;
450 216 $single_quoted_name =~ s/ \s+ / /gxms;
451 216 return $single_quoted_name;
452 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::single_quoted_name::name
453  
454 sub Marpa::R3::Internal::MetaAST_Nodes::parenthesized_rhs_primary_list::evaluate
455 77 ▶{
Subroutine evaluate: called CC=1 SCAR=0.0
456 77 my ( $data, $parse ) = @_;
457 77 my ( undef, undef, @values ) = @{$data};
458 77 my @symbol_lists = map { $_->evaluate($parse); } @values;
459 77 my $flattened_list =
460 Marpa::R3::Internal::MetaAST::Symbol_List->combine(@symbol_lists);
461 77 $flattened_list->mask_set(0);
462 77 return $flattened_list;
463 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::parenthesized_rhs_primary_list::evaluate
464  
465 1808 ▶sub Marpa::R3::Internal::MetaAST_Nodes::rhs::evaluate {
Subroutine evaluate: called CC=2 SCAR=7.3
466 1808 my ( $data, $parse ) = @_;
467 1808 my ( $start, $length, @values ) = @{$data};
468 1808 my $rhs = eval {
469 1808 my @symbol_lists = map { $_->evaluate($parse) } @values;
470 1808 my $flattened_list =
471 Marpa::R3::Internal::MetaAST::Symbol_List->combine(@symbol_lists);
472 1808 bless {
473 rhs => $flattened_list->names($parse),
474 mask => $flattened_list->mask()
475 },
476 $PROTO_ALTERNATIVE;
477 };
478 1808 ▶ if ( not $rhs ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($rhs) 0 1808 1808
479 0 my $eval_error = $EVAL_ERROR;
480 0 chomp $eval_error;
481 0 Marpa::R3::exception(
482 qq{$eval_error\n},
483 q{ RHS involved was },
484 $parse->substring( $start, $length )
485 );
486 } ## end if ( not $rhs )
487 1808 return $rhs;
488 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::rhs::evaluate
489  
490 3086 ▶sub Marpa::R3::Internal::MetaAST_Nodes::rhs_primary::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
491 3086 my ( $data, $parse ) = @_;
492 3086 my ( undef, undef, @values ) = @{$data};
493 3086 my @symbol_lists = map { $_->evaluate($parse) } @values;
494 3086 return Marpa::R3::Internal::MetaAST::Symbol_List->combine(@symbol_lists);
495 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::rhs_primary::evaluate
496  
497 77 ▶sub Marpa::R3::Internal::MetaAST_Nodes::rhs_primary_list::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
498 77 my ( $data, $parse ) = @_;
499 77 my ( undef, undef, @values ) = @{$data};
500 77 my @symbol_lists = map { $_->evaluate($parse) } @values;
501 77 return Marpa::R3::Internal::MetaAST::Symbol_List->combine(@symbol_lists);
502 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::rhs_primary_list::evaluate
503  
504 490 ▶sub Marpa::R3::Internal::MetaAST_Nodes::action::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
505 490 my ( $values, $parse ) = @_;
506 490 my ( undef, undef, $child ) = @{$values};
507 490 return bless { action => $child->name($parse) }, $PROTO_ALTERNATIVE;
508 }
509  
510 119 ▶sub Marpa::R3::Internal::MetaAST_Nodes::blessing::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
511 119 my ( $values, $parse ) = @_;
512 119 my ( undef, undef, $child ) = @{$values};
513 119 return bless { bless => $child->name($parse) }, $PROTO_ALTERNATIVE;
514 }
515  
516 10 ▶sub Marpa::R3::Internal::MetaAST_Nodes::naming::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
517 10 my ( $values, $parse ) = @_;
518 10 my ( undef, undef, $child ) = @{$values};
519 10 return bless { name => $child->name($parse) }, $PROTO_ALTERNATIVE;
520 }
521  
522 9 ▶sub Marpa::R3::Internal::MetaAST_Nodes::right_association::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
523 9 my ($values) = @_;
524 9 return bless { assoc => 'R' }, $PROTO_ALTERNATIVE;
525 }
526  
527 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::left_association::evaluate {
Subroutine evaluate: not called CC=1 SCAR=6.9
528 0 my ($values) = @_;
529 0 return bless { assoc => 'L' }, $PROTO_ALTERNATIVE;
530 }
531  
532 10 ▶sub Marpa::R3::Internal::MetaAST_Nodes::group_association::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
533 10 my ($values) = @_;
534 10 return bless { assoc => 'G' }, $PROTO_ALTERNATIVE;
535 }
536  
537 21 ▶sub Marpa::R3::Internal::MetaAST_Nodes::eager_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
538 21 my ($values) = @_;
539 21 my $child = $values->[2];
540 21 return bless { eager => $child->value() }, $PROTO_ALTERNATIVE;
541 }
542  
543 139 ▶sub Marpa::R3::Internal::MetaAST_Nodes::event_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
544 139 my ($values) = @_;
545 139 return bless { event => ( $values->[2]->event() ) }, $PROTO_ALTERNATIVE;
546 }
547  
548 300 ▶sub Marpa::R3::Internal::MetaAST_Nodes::event_initialization::event {
Subroutine event: called CC=1 SCAR=0.0
549 300 my ($values) = @_;
550 300 my $event_name = $values->[2];
551 300 my $event_initializer = $values->[3];
552 300 return [$event_name->name(), $event_initializer->on_or_off()],
553 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::event_specification::evaluate
554  
555 4 ▶sub Marpa::R3::Internal::MetaAST_Nodes::proper_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
556 4 my ($values) = @_;
557 4 my $child = $values->[2];
558 4 return bless { proper => $child->value() }, $PROTO_ALTERNATIVE;
559 }
560  
561 61 ▶sub Marpa::R3::Internal::MetaAST_Nodes::pause_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
562 61 my ($values) = @_;
563 61 my $child = $values->[2];
564 61 return bless { pause => $child->value() }, $PROTO_ALTERNATIVE;
565 }
566  
567 2 ▶sub Marpa::R3::Internal::MetaAST_Nodes::priority_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
568 2 my ($values) = @_;
569 2 my $child = $values->[2];
570 2 return bless { priority => $child->value() }, $PROTO_ALTERNATIVE;
571 }
572  
573 51 ▶sub Marpa::R3::Internal::MetaAST_Nodes::rank_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
574 51 my ($values) = @_;
575 51 my $child = $values->[2];
576 51 return bless { rank => $child->value() }, $PROTO_ALTERNATIVE;
577 }
578  
579 2 ▶sub Marpa::R3::Internal::MetaAST_Nodes::null_ranking_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
580 2 my ($values) = @_;
581 2 my $child = $values->[2];
582 2 return bless { null_ranking => $child->value() }, $PROTO_ALTERNATIVE;
583 }
584  
585 2 ▶sub Marpa::R3::Internal::MetaAST_Nodes::null_ranking_constant::value {
Subroutine value: called CC=1 SCAR=0.0
586 2 return $_[0]->[2];
587 }
588  
589 61 ▶sub Marpa::R3::Internal::MetaAST_Nodes::before_or_after::value {
Subroutine value: called CC=1 SCAR=0.0
590 61 return $_[0]->[2];
591 }
592  
593 sub Marpa::R3::Internal::MetaAST_Nodes::event_initializer::on_or_off
594 300 ▶{
Subroutine on_or_off: called CC=3 SCAR=11.0
595 300 my ($values) = @_;
596 300 my (undef, undef, $is_activated) = @{$values};
597 300 ▶ return 1 if not defined $is_activated;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $is_activated 195 105 300
598 105 my (undef, undef, $on_or_off) = @{$is_activated};
599 105 ▶ return $on_or_off eq 'on' ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$on_or_off eq 'on' ? : 22 83 105
600 }
601  
602 25 ▶sub Marpa::R3::Internal::MetaAST_Nodes::boolean::value {
Subroutine value: called CC=1 SCAR=0.0
603 25 return $_[0]->[2];
604 }
605  
606 53 ▶sub Marpa::R3::Internal::MetaAST_Nodes::signed_integer::value {
Subroutine value: called CC=1 SCAR=0.0
607 53 return $_[0]->[2];
608 }
609  
610 19 ▶sub Marpa::R3::Internal::MetaAST_Nodes::separator_specification::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
611 19 my ( $values, $parse ) = @_;
612 19 my $child = $values->[2];
613 19 return bless { separator => $child->name($parse) }, $PROTO_ALTERNATIVE;
614 }
615  
616 943 ▶sub Marpa::R3::Internal::MetaAST_Nodes::adverb_item::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
617 943 my ( $values, $parse ) = @_;
618 943 my $child = $values->[2]->evaluate($parse);
619 943 return bless $child, $PROTO_ALTERNATIVE;
620 }
621  
622 139 ▶sub Marpa::R3::Internal::MetaAST_Nodes::default_rule::evaluate {
Subroutine evaluate: called CC=7 SCAR=20.0
623 139 my ( $values, $parse ) = @_;
624 139 my ( $start, $length, undef, $op_declare, $raw_adverb_list ) = @{$values};
625 139 ▶ my $subgrammar = $op_declare->op() eq q{::=} ? 'g1' : 'l0';
Branch: 1 branch
BranchTrueFalseTotal
$op_declare->op eq '::=' ? : 139 0 139
626 139 my $adverb_list = $raw_adverb_list->evaluate($parse);
627  
628 # A default rule clears the previous default
629 139 my %default_adverbs = ();
630 139 $parse->{default_adverbs}->{$subgrammar} = \%default_adverbs;
631  
632 139 ADVERB: for my $key ( keys %{$adverb_list} ) {
633 150 my $value = $adverb_list->{$key};
634 150 ▶ if ( $key eq 'action' and $subgrammar eq 'g1' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action" and $subgrammar eq "g1") 139 11 150
Condition66%2/3
$key eq "action" and $subgrammar eq "g1"
!ll&&!rl&&r
110139
MC/DC50%1/2
$key eq "action" and $subgrammar eq "g1"
$key eq "action" $subgrammar eq "g1"
Truth table66%2/3
A and B
A= $key eq "action"B= $subgrammar eq "g1"
ABresult
0X0
100
111
635 139 $default_adverbs{$key} = $adverb_list->{$key};
636 139 next ADVERB;
637 }
638 11 ▶ if ( $key eq 'bless' and $subgrammar eq 'g1' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless" and $subgrammar eq "g1") 11 0 11
Condition33%1/3
$key eq "bless" and $subgrammar eq "g1"
!ll&&!rl&&r
0011
MC/DC0%0/2
$key eq "bless" and $subgrammar eq "g1"
$key eq "bless" $subgrammar eq "g1"
Truth table33%1/3
A and B
A= $key eq "bless"B= $subgrammar eq "g1"
ABresult
0X0
100
111
639 11 $default_adverbs{$key} = $adverb_list->{$key};
640 11 next ADVERB;
641 }
642 0 die qq{Adverb "$key" not allowed in $subgrammar default rule\n},
643 ' Rule was ', $parse->substring( $start, $length ), "\n";
644 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
645 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
646 139 return undef;
647 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::default_rule::evaluate
648  
649 27 ▶sub Marpa::R3::Internal::MetaAST_Nodes::discard_default_statement::evaluate {
Subroutine evaluate: called CC=5 SCAR=17.3
650 27 my ( $data, $parse ) = @_;
651 27 my ( $start, $length, $raw_adverb_list ) = @{$data};
652 27 local $Marpa::R3::Internal::SUBGRAMMAR = 'g1';
653  
654 27 my $adverb_list = $raw_adverb_list->evaluate($parse);
655 27 ▶ if ( exists $parse->{discard_default_adverbs} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $parse->{"discard_default_adverbs"}) 0 27 27
656 0 my $problem_rule = $parse->substring( $start, $length );
657 0 Marpa::R3::exception(
658 qq{More than one discard default statement is not allowed\n},
659 qq{ This was the rule that caused the problem:\n},
660 qq{ $problem_rule\n}
661 );
662 } ## end if ( exists $parse->{discard_default_adverbs} )
663 27 $parse->{discard_default_adverbs} = {};
664 27 ADVERB: for my $key ( keys %{$adverb_list} ) {
665 27 my $value = $adverb_list->{$key};
666 27 ▶ if ( $key eq 'event' and defined $value ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "event" and defined $value) 27 0 27
Condition33%1/3
$key eq "event" and defined $value
!ll&&!rl&&r
0027
MC/DC0%0/2
$key eq "event" and defined $value
$key eq "event" defined $value
Truth table33%1/3
A and B
A= $key eq "event"B= defined $value
ABresult
0X0
100
111
667 27 $parse->{discard_default_adverbs}->{$key} = $value;
668 27 next ADVERB;
669 }
670 Marpa::R3::exception(
671 0 qq{"$key" adverb not allowed as discard default"});
672 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
673 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
674 27 return undef;
675 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::discard_default_statement::evaluate
676  
677 44 ▶sub Marpa::R3::Internal::MetaAST_Nodes::lexeme_default_statement::evaluate {
Subroutine evaluate: called CC=5 SCAR=16.4
678 44 my ( $data, $parse ) = @_;
679 44 my ( $start, $length, $raw_adverb_list ) = @{$data};
680 44 local $Marpa::R3::Internal::SUBGRAMMAR = 'g1';
681  
682 44 my $adverb_list = $raw_adverb_list->evaluate($parse);
683 44 ▶ if ( exists $parse->{lexeme_default_adverbs} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $parse->{"lexeme_default_adverbs"}) 0 44 44
684 0 my $problem_rule = $parse->substring( $start, $length );
685 0 Marpa::R3::exception(
686 qq{More than one lexeme default statement is not allowed\n},
687 qq{ This was the rule that caused the problem:\n},
688 qq{ $problem_rule\n}
689 );
690 } ## end if ( exists $parse->{lexeme_default_adverbs} )
691 44 $parse->{lexeme_default_adverbs} = {};
692 44 ADVERB: for my $key ( keys %{$adverb_list} ) {
693 50 my $value = $adverb_list->{$key};
694 50 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 44 6 50
695 44 $parse->{lexeme_default_adverbs}->{$key} = $value;
696 44 next ADVERB;
697 }
698 6 ▶ if ( $key eq 'bless' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless") 6 0 6
699 6 $parse->{lexeme_default_adverbs}->{$key} = $value;
700 6 next ADVERB;
701 }
702 Marpa::R3::exception(
703 0 qq{"$key" adverb not allowed as lexeme default"});
704 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
705 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
706 44 return undef;
707 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::lexeme_default_statement::evaluate
708  
709 9 ▶sub Marpa::R3::Internal::MetaAST_Nodes::inaccessible_statement::evaluate {
Subroutine evaluate: called CC=2 SCAR=7.3
710 9 my ( $data, $parse ) = @_;
711 9 my ( $start, $length, $inaccessible_treatment ) = @{$data};
712 9 local $Marpa::R3::Internal::SUBGRAMMAR = 'g1';
713  
714 9 ▶ if ( exists $parse->{defaults}->{if_inaccessible} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $parse->{"defaults"}{"if_inaccessible"}) 0 9 9
715 0 my $problem_rule = $parse->substring( $start, $length );
716 0 Marpa::R3::exception(
717 qq{More than one inaccessible default statement is not allowed\n},
718 qq{ This was the rule that caused the problem:\n},
719 qq{ $problem_rule\n}
720 );
721 }
722 9 $parse->{defaults}->{if_inaccessible} = $inaccessible_treatment->value();
723 9 return undef;
724 }
725  
726 9 ▶sub Marpa::R3::Internal::MetaAST_Nodes::inaccessible_treatment::value {
Subroutine value: called CC=1 SCAR=0.0
727 9 return $_[0]->[2];
728 }
729  
730 1448 ▶sub Marpa::R3::Internal::MetaAST_Nodes::priority_rule::evaluate {
Subroutine evaluate: called CC=73 SCAR=48.1
731 1448 my ( $values, $parse ) = @_;
732 my ( $start, $length, $raw_lhs, $op_declare, $raw_priorities ) =
733 1448 @{$values};
734  
735 1448 ▶ my $subgrammar = $op_declare->op() eq q{::=} ? 'g1' : 'l0';
Branch: 1 branch
BranchTrueFalseTotal
$op_declare->op eq '::=' ? : 765 683 1448
736 1448 my $xpr_ordinal = 0;
737  
738 1448 my $lhs = $raw_lhs->name($parse);
739 1448 ▶ $parse->{'first_lhs'} //= $lhs if $subgrammar eq 'g1';
Branch: 1 branch
BranchTrueFalseTotal
if $subgrammar eq "g1" 765 683 1448
Condition66%2/3
$parse->{"first_lhs"} //= $lhs
l!l&&r!l&&!r
5372280
MC/DC0%0/2
$parse->{"first_lhs"} //= $lhs
$parse->{"first_lhs"} $lhs
Truth table66%2/3
A //= B
A= $parse->{"first_lhs"}B= $lhs
ABresult
1X1
011
000
740 1448 local $Marpa::R3::Internal::SUBGRAMMAR = $subgrammar;
741  
742 1448 my ( undef, undef, @priorities ) = @{$raw_priorities};
743 1448 my $priority_count = scalar @priorities;
744 1448 my @working_rules = ();
745  
746 1448 ▶ $parse->{rules}->{$subgrammar} //= [];
Condition50%1/2
$parse->{"rules"}{$subgrammar} //= []
l!l
14480
MC/DC0%0/1
$parse->{"rules"}{$subgrammar} //= []
$parse->{"rules"}{$subgrammar}
Truth table50%1/2
A
A= $parse->{"rules"}{$subgrammar}
Aresult
11
00
747 1448 my $rules = $parse->{rules}->{$subgrammar};
748  
749 1448 my $default_adverbs = $parse->{default_adverbs}->{$subgrammar};
750  
751 1448 my $xrlid = xrl_create($parse, {
752 lhs => $lhs,
753 start => $start,
754 length => $length,
755 precedence_count => $priority_count,
756 }
757 );
758 1446 ▶ if ( $priority_count <= 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($priority_count <= 1) 1427 19 1446
759 ## If there is only one priority
760 1427 my ( undef, undef, @alternatives ) = @{ $priorities[0] };
761  
762 1427 for my $alternative_ix (0 .. $#alternatives) {
763 my ($alternative_start, $alternative_length,
764 $raw_rhs, $raw_adverb_list
765 1703 ) = @{$alternatives[$alternative_ix]};
766 1703 my ( $proto_rule, $adverb_list );
767 1703 my $eval_ok = eval {
768 1703 $proto_rule = $raw_rhs->evaluate($parse);
769 1703 $adverb_list = $raw_adverb_list->evaluate($parse);
770 1703 1;
771 };
772 1703 ▶ if ( not $eval_ok ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($eval_ok) 0 1703 1703
773 0 my $eval_error = $EVAL_ERROR;
774 0 chomp $eval_error;
775 0 Marpa::R3::exception(
776 qq{$eval_error\n},
777 qq{ The problem was in this RHS alternative:\n},
778 q{ },
779 $parse->substring( $alternative_start, $alternative_length ),
780 "\n"
781 );
782 } ## end if ( not $eval_ok )
783 1703 my @rhs_names = @{ $proto_rule->{rhs} };
784 1703 my @mask = @{ $proto_rule->{mask} };
785 1703 ▶ if ( ( substr $subgrammar, 0, 1 ) eq 'l'
Branch: 1 branch
BranchTrueFalseTotal
if (substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask) 0 1703 1703
Condition66%2/3
substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask
!ll&&!rl&&r
9127910
MC/DC0%0/2
substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask
substr($subgrammar, 0, 1) eq "l" grep {not $_;} @mask
Truth table66%2/3
A and B
A= substr($subgrammar, 0, 1) eq "l"B= grep {not $_;} @mask
ABresult
0X0
100
111
786 1388 and grep { !$_ } @mask )
787 {
788 0 Marpa::R3::exception(
789 qq{hidden symbols are not allowed in lexical rules (rule's LHS was "$lhs")}
790 );
791 }
792 1703 $parse->symbol_assign_ordinary($_, $subgrammar) for $lhs, @rhs_names;
793 1703 ▶ my %hash_rule = (
Branch: 2 branches
BranchTrueFalseTotal
$alternative_ix ? : 276 1427 1703
$alternative_ix ? : 276 1427 1703
794 start => ( $alternative_ix ? $alternative_start : $start ),
795 length => ( $alternative_ix ? $alternative_length : $length ),
796 subkey => ++$xpr_ordinal,
797 lhs => $lhs,
798 rhs => \@rhs_names,
799 mask => \@mask,
800 xrlid => $xrlid,
801 );
802  
803 1703 my $action;
804 my $blessing;
805 1703 my $naming;
806 1703 my $null_ranking;
807 1703 my $rank;
808 1703 ADVERB: for my $key ( keys %{$adverb_list} ) {
809 315 my $value = $adverb_list->{$key};
810 315 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 204 111 315
811 204 $action = $adverb_list->{$key};
812 204 next ADVERB;
813 }
814 111 ▶ if ( $key eq 'assoc' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "assoc") 0 111 111
815  
816 # OK, but ignored
817 0 next ADVERB;
818 }
819 111 ▶ if ( $key eq 'bless' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless") 48 63 111
820 48 $blessing = $adverb_list->{$key};
821 48 next ADVERB;
822 }
823 63 ▶ if ( $key eq 'name' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "name") 10 53 63
824 10 $naming = $adverb_list->{$key};
825 10 next ADVERB;
826 }
827 53 ▶ if ( $key eq 'null_ranking' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "null_ranking") 2 51 53
828 2 $null_ranking = $adverb_list->{$key};
829 2 next ADVERB;
830 }
831 51 ▶ if ( $key eq 'rank' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "rank") 51 0 51
832 51 $rank = $adverb_list->{$key};
833 51 next ADVERB;
834 }
835 my ( $line, $column ) =
836 0 $parse->{meta_recce}->line_column(undef, $start);
837 0 die qq{Adverb "$key" not allowed in an prioritized rule\n},
838 ' Rule was ', $parse->substring( $start, $length ), "\n";
839 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
840  
841 1703 ▶ $action //= $default_adverbs->{action};
Condition100%3/3
$action //= $default_adverbs->{"action"}
l!l&&r!l&&!r
2043411158
MC/DC100%2/2
$action //= $default_adverbs->{"action"}
$action $default_adverbs->{"action"}
Truth table100%3/3
A //= B
A= $actionB= $default_adverbs->{"action"}
ABresult
1X1
011
000
842 1703 ▶ if ( defined $action ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $action) 545 1158 1703
843 545 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 545 545
844 qq{actions not allowed in lexical rules (rule's LHS was "$lhs")}
845 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
846 545 $hash_rule{action} = $action;
847 } ## end if ( defined $action )
848  
849 1703 ▶ $rank //= $default_adverbs->{rank};
Condition66%2/3
$rank //= $default_adverbs->{"rank"}
l!l&&r!l&&!r
5101652
MC/DC50%1/2
$rank //= $default_adverbs->{"rank"}
$rank $default_adverbs->{"rank"}
Truth table66%2/3
A //= B
A= $rankB= $default_adverbs->{"rank"}
ABresult
1X1
011
000
850 1703 ▶ if ( defined $rank ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $rank) 51 1652 1703
851 51 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 51 51
852 qq{ranks not allowed in lexical rules (rule's LHS was "$lhs")}
853 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
854 51 $hash_rule{rank} = $rank;
855 } ## end if ( defined $rank )
856  
857 1703 ▶ $null_ranking //= $default_adverbs->{null_ranking};
Condition66%2/3
$null_ranking //= $default_adverbs->{"null_ranking"}
l!l&&r!l&&!r
201701
MC/DC50%1/2
$null_ranking //= $default_adverbs->{"null_ranking"}
$null_ranking $default_adverbs->{"null_ranking"}
Truth table66%2/3
A //= B
A= $null_rankingB= $default_adverbs->{"null_ranking"}
ABresult
1X1
011
000
858 1703 ▶ if ( defined $null_ranking ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $null_ranking) 2 1701 1703
859 2 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 2 2
860 qq{null-ranking allowed in lexical rules (rule's LHS was "$lhs")}
861 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
862 2 $hash_rule{null_ranking} = $null_ranking;
863 } ## end if ( defined $rank )
864  
865 1703 ▶ $blessing //= $default_adverbs->{bless};
Condition100%3/3
$blessing //= $default_adverbs->{"bless"}
l!l&&r!l&&!r
4881647
MC/DC100%2/2
$blessing //= $default_adverbs->{"bless"}
$blessing $default_adverbs->{"bless"}
Truth table100%3/3
A //= B
A= $blessingB= $default_adverbs->{"bless"}
ABresult
1X1
011
000
866 1703 ▶ if (defined $blessing
Branch: 1 branch
BranchTrueFalseTotal
if (defined $blessing and substr($subgrammar, 0, 1) eq "l") 0 1703 1703
Condition66%2/3
defined $blessing and substr($subgrammar, 0, 1) eq "l"
!ll&&!rl&&r
1647560
MC/DC0%0/2
defined $blessing and substr($subgrammar, 0, 1) eq "l"
defined $blessing substr($subgrammar, 0, 1) eq "l"
Truth table66%2/3
A and B
A= defined $blessingB= substr($subgrammar, 0, 1) eq "l"
ABresult
0X0
100
111
867 and
868 ( substr $subgrammar, 0, 1 ) eq 'l'
869 )
870 {
871 0 Marpa::R3::exception(
872 'bless option not allowed in lexical rules (rules LHS was "',
873 $lhs, '")'
874 );
875 }
876  
877 1703 $parse->bless_hash_rule( \%hash_rule, $blessing, $naming, $lhs );
878  
879 1703 my $wrl = $parse->xpr_create( \%hash_rule, $subgrammar );
880 1701 push @{$rules}, $wrl;
881 } ## end for my $alternative (@alternatives)
882 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
883 1425 return undef;
884 } ## end if ( $priority_count <= 1 )
885  
886 19 for my $priority_ix ( 0 .. $priority_count - 1 ) {
887 70 my $priority = $priority_count - ( $priority_ix + 1 );
888 70 my ( undef, undef, @alternatives ) = @{ $priorities[$priority_ix] };
889 70 for my $alternative (@alternatives) {
890 my ($alternative_start, $alternative_length,
891 $raw_rhs, $raw_adverb_list
892 105 ) = @{$alternative};
893 105 my ( $adverb_list, $rhs );
894 105 my $eval_ok = eval {
895 105 $adverb_list = $raw_adverb_list->evaluate($parse);
896 105 $rhs = $raw_rhs->evaluate($parse);
897 105 1;
898 };
899 105 ▶ if ( not $eval_ok ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($eval_ok) 0 105 105
900 0 my $eval_error = $EVAL_ERROR;
901 0 chomp $eval_error;
902 0 Marpa::R3::exception(
903 qq{$eval_error\n},
904 qq{ The problem was in this RHS alternative:\n},
905 q{ },
906 $parse->substring( $alternative_start, $alternative_length ),
907 "\n"
908 );
909 } ## end if ( not $eval_ok )
910 105 push @working_rules, [ $priority, $rhs, $adverb_list, $alternative_start, $alternative_length ];
911 } ## end for my $alternative (@alternatives)
912 } ## end for my $priority_ix ( 0 .. $priority_count - 1 )
913  
914 # Default mask (all ones) is OK for this rule
915 19 my @arg0_action = ();
916 19 ▶ @arg0_action = ( action => '::first' ) if $subgrammar eq 'g1';
Branch: 1 branch
BranchTrueFalseTotal
if $subgrammar eq "g1" 19 0 19
917  
918 # Internal rule top priority rule for <$lhs>
919 19 $parse->symbol_assign_ordinary($lhs, $subgrammar);
920 19 my @priority_rules = (
921 {
922 start => $start,
923 length => $length,
924 lhs => $lhs,
925 rhs => [ $parse->prioritized_symbol( $lhs, 0 ) ],
926 precedence => -1,
927 subkey => ++$xpr_ordinal,
928 @arg0_action,
929 }
930 );
931  
932 # Internal rule for symbol <$lhs> priority transition
933 push @priority_rules,
934 {
935 start => $start,
936 length => $length,
937 lhs => $parse->prioritized_symbol( $lhs, $_ - 1 ),
938 rhs => [ $parse->prioritized_symbol( $lhs, $_ ) ],
939 precedence => ($_ - 1),
940 subkey => ++$xpr_ordinal,
941 @arg0_action
942 }
943 19 for 1 .. $priority_count - 1;
944 19 RULE: for my $priority_rule (@priority_rules) {
945 70 my $wrl = $parse->xpr_create( $priority_rule, $subgrammar );
946 70 push @{$rules}, $wrl;
947 }
948  
949 19 RULE: for my $working_rule (@working_rules) {
950 105 my ( $priority, $rhs, $adverb_list, $alternative_start, $alternative_length ) = @{$working_rule};
951 105 my @new_rhs = @{ $rhs->{rhs} };
952 105 my @arity = grep { $new_rhs[$_] eq $lhs } 0 .. $#new_rhs;
953 105 my $rhs_length = scalar @new_rhs;
954  
955 105 my $current_exp = $parse->prioritized_symbol( $lhs, $priority );
956 105 my @mask = @{ $rhs->{mask} };
957 0 ▶ if ( ( substr $subgrammar, 0, 1 ) eq 'l' and grep { !$_ } @mask )
Branch: 1 branch
BranchTrueFalseTotal
if (substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask) 0 105 105
Condition33%1/3
substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask
!ll&&!rl&&r
10500
MC/DC0%0/2
substr($subgrammar, 0, 1) eq "l" and grep {not $_;} @mask
substr($subgrammar, 0, 1) eq "l" grep {not $_;} @mask
Truth table33%1/3
A and B
A= substr($subgrammar, 0, 1) eq "l"B= grep {not $_;} @mask
ABresult
0X0
100
111
958 {
959 0 Marpa::R3::exception(
960 'hidden symbols are not allowed in lexical rules (rules LHS was "',
961 $lhs, '")'
962 );
963 }
964 105 my %new_xs_rule = (
965 lhs => $current_exp,
966 start => $alternative_start,
967 length => $alternative_length,
968 subkey => ++$xpr_ordinal,
969 xrlid => $xrlid,
970 );
971 105 $new_xs_rule{mask} = \@mask;
972  
973 105 my $action;
974 my $assoc;
975 105 my $blessing;
976 105 my $naming;
977 105 my $rank;
978 105 my $null_ranking;
979 105 ADVERB: for my $key ( keys %{$adverb_list} ) {
980 98 my $value = $adverb_list->{$key};
981 98 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 29 69 98
982 29 $action = $adverb_list->{$key};
983 29 next ADVERB;
984 }
985 69 ▶ if ( $key eq 'assoc' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "assoc") 19 50 69
986 19 $assoc = $adverb_list->{$key};
987 19 next ADVERB;
988 }
989 50 ▶ if ( $key eq 'bless' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless") 50 0 50
990 50 $blessing = $adverb_list->{$key};
991 50 next ADVERB;
992 }
993 0 ▶ if ( $key eq 'name' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "name") 0 0 0
994 0 $naming = $adverb_list->{$key};
995 0 next ADVERB;
996 }
997 0 ▶ if ( $key eq 'null_ranking' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "null_ranking") 0 0 0
998 0 $null_ranking = $adverb_list->{$key};
999 0 next ADVERB;
1000 }
1001 0 ▶ if ( $key eq 'rank' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "rank") 0 0 0
1002 0 $rank = $adverb_list->{$key};
1003 0 next ADVERB;
1004 }
1005 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1006 0 die qq{Adverb "$key" not allowed in a prioritized rule\n},
1007 ' Rule was ', $parse->substring( $start, $length ), "\n";
1008 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
1009  
1010 105 ▶ $assoc //= 'L';
Condition100%2/2
$assoc //= "L"
l!l
1986
MC/DC100%1/1
$assoc //= "L"
$assoc
Truth table100%2/2
A
A= $assoc
Aresult
11
00
1011  
1012 105 ▶ $action //= $default_adverbs->{action};
Condition100%3/3
$action //= $default_adverbs->{"action"}
l!l&&r!l&&!r
29706
MC/DC100%2/2
$action //= $default_adverbs->{"action"}
$action $default_adverbs->{"action"}
Truth table100%3/3
A //= B
A= $actionB= $default_adverbs->{"action"}
ABresult
1X1
011
000
1013 105 ▶ if ( defined $action ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $action) 99 6 105
1014 99 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 99 99
1015 qq{actions not allowed in lexical rules (rule's LHS was "$lhs")}
1016 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1017 99 $new_xs_rule{action} = $action;
1018 } ## end if ( defined $action )
1019  
1020 105 ▶ $null_ranking //= $default_adverbs->{null_ranking};
Condition33%1/3
$null_ranking //= $default_adverbs->{"null_ranking"}
l!l&&r!l&&!r
00105
MC/DC0%0/2
$null_ranking //= $default_adverbs->{"null_ranking"}
$null_ranking $default_adverbs->{"null_ranking"}
Truth table33%1/3
A //= B
A= $null_rankingB= $default_adverbs->{"null_ranking"}
ABresult
1X1
011
000
1021 105 ▶ if ( defined $null_ranking ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $null_ranking) 0 105 105
1022 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1023 qq{null-ranking not allowed in lexical rules (rule's LHS was "$lhs")}
1024 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1025 0 $new_xs_rule{null_ranking} = $null_ranking;
1026 } ## end if ( defined $rank )
1027  
1028 105 ▶ $rank //= $default_adverbs->{rank};
Condition33%1/3
$rank //= $default_adverbs->{"rank"}
l!l&&r!l&&!r
00105
MC/DC0%0/2
$rank //= $default_adverbs->{"rank"}
$rank $default_adverbs->{"rank"}
Truth table33%1/3
A //= B
A= $rankB= $default_adverbs->{"rank"}
ABresult
1X1
011
000
1029 105 ▶ if ( defined $rank ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $rank) 0 105 105
1030 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1031 qq{ranks not allowed in lexical rules (rule's LHS was "$lhs")}
1032 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1033 0 $new_xs_rule{rank} = $rank;
1034 } ## end if ( defined $rank )
1035  
1036 105 ▶ $blessing //= $default_adverbs->{bless};
Condition100%3/3
$blessing //= $default_adverbs->{"bless"}
l!l&&r!l&&!r
501639
MC/DC100%2/2
$blessing //= $default_adverbs->{"bless"}
$blessing $default_adverbs->{"bless"}
Truth table100%3/3
A //= B
A= $blessingB= $default_adverbs->{"bless"}
ABresult
1X1
011
000
1037 105 ▶ if ( defined $blessing
Branch: 1 branch
BranchTrueFalseTotal
if (defined $blessing and substr($subgrammar, 0, 1) eq "l") 0 105 105
Condition66%2/3
defined $blessing and substr($subgrammar, 0, 1) eq "l"
!ll&&!rl&&r
39660
MC/DC0%0/2
defined $blessing and substr($subgrammar, 0, 1) eq "l"
defined $blessing substr($subgrammar, 0, 1) eq "l"
Truth table66%2/3
A and B
A= defined $blessingB= substr($subgrammar, 0, 1) eq "l"
ABresult
0X0
100
111
1038 and ( substr $subgrammar, 0, 1 ) eq 'l' )
1039 {
1040 0 Marpa::R3::exception(
1041 'bless option not allowed in lexical rules (rules LHS was "',
1042 $lhs, '")'
1043 );
1044 }
1045  
1046 105 $parse->bless_hash_rule( \%new_xs_rule, $blessing, $naming, $lhs );
1047  
1048 105 my $next_priority = $priority + 1;
1049  
1050 # This is probably a mis-feature. It probably should be
1051 # $next_priority = $priority if $next_priority >= $priority_count;
1052 # However, I probably will not change this, because some apps
1053 # may be relying on this behavior.
1054 105 ▶ $next_priority = 0 if $next_priority >= $priority_count;
Branch: 1 branch
BranchTrueFalseTotal
if $next_priority >= $priority_count 36 69 105
1055  
1056 105 my $next_exp = $parse->prioritized_symbol( $lhs, $next_priority);
1057 105 $new_xs_rule{precedence} = $priority;
1058  
1059 105 ▶ if ( not scalar @arity ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (scalar @arity) 28 77 105
1060 28 $new_xs_rule{rhs} = \@new_rhs;
1061 28 $parse->symbol_assign_ordinary($_, $subgrammar) for @new_rhs;
1062 28 my $wrl = $parse->xpr_create( \%new_xs_rule, $subgrammar );
1063 28 push @{$rules}, $wrl;
1064 28 next RULE;
1065 }
1066  
1067 77 ▶ if ( scalar @arity == 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @arity == 1) 15 62 77
1068 15 ▶ die 'Unnecessary unit rule in priority rule' if $rhs_length == 1;
Branch: 1 branch
BranchTrueFalseTotal
if $rhs_length == 1 0 15 15
1069 15 $new_rhs[ $arity[0] ] = $current_exp;
1070 }
1071 DO_ASSOCIATION: {
1072 77 ▶ if ( $assoc eq 'L' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($assoc eq "L") 58 19 77
1073 58 $new_rhs[ $arity[0] ] = $current_exp;
1074 58 for my $rhs_ix ( @arity[ 1 .. $#arity ] ) {
1075 53 $new_rhs[$rhs_ix] = $next_exp;
1076 }
1077 58 last DO_ASSOCIATION;
1078 } ## end if ( $assoc eq 'L' )
1079 19 ▶ if ( $assoc eq 'R' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($assoc eq "R") 9 10 19
1080 9 $new_rhs[ $arity[-1] ] = $current_exp;
1081 9 for my $rhs_ix ( @arity[ 0 .. $#arity - 1 ] ) {
1082 9 $new_rhs[$rhs_ix] = $next_exp;
1083 }
1084 9 last DO_ASSOCIATION;
1085 } ## end if ( $assoc eq 'R' )
1086 10 ▶ if ( $assoc eq 'G' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($assoc eq "G") 10 0 10
1087 10 for my $rhs_ix ( @arity[ 0 .. $#arity ] ) {
1088 10 $new_rhs[$rhs_ix] = $parse->prioritized_symbol( $lhs, 0 );
1089 }
1090 10 last DO_ASSOCIATION;
1091 } ## end if ( $assoc eq 'G' )
1092 0 die qq{Unknown association type: "$assoc"};
1093 } ## end DO_ASSOCIATION:
1094  
1095 77 $parse->symbol_assign_ordinary($_, $subgrammar) for @new_rhs;
1096 77 $new_xs_rule{rhs} = \@new_rhs;
1097 77 my $wrl = $parse->xpr_create( \%new_xs_rule, $subgrammar );
1098 77 push @{$rules}, $wrl;
1099 } ## end RULE: for my $working_rule (@working_rules)
1100 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1101 19 return undef;
1102 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::priority_rule::evaluate
1103  
1104 96 ▶sub Marpa::R3::Internal::MetaAST_Nodes::empty_rule::evaluate {
Subroutine evaluate: called CC=22 SCAR=41.5
1105 96 my ( $values, $parse ) = @_;
1106 my ( $start, $length, $raw_lhs, $op_declare, $raw_adverb_list ) =
1107 96 @{$values};
1108  
1109 96 ▶ my $subgrammar = $op_declare->op() eq q{::=} ? 'g1' : 'l0';
Branch: 1 branch
BranchTrueFalseTotal
$op_declare->op eq '::=' ? : 95 1 96
1110  
1111 96 my $lhs = $raw_lhs->name($parse);
1112 96 ▶ $parse->{'first_lhs'} //= $lhs if $subgrammar eq 'g1';
Branch: 1 branch
BranchTrueFalseTotal
if $subgrammar eq "g1" 95 1 96
Condition66%2/3
$parse->{"first_lhs"} //= $lhs
l!l&&r!l&&!r
79160
MC/DC0%0/2
$parse->{"first_lhs"} //= $lhs
$parse->{"first_lhs"} $lhs
Truth table66%2/3
A //= B
A= $parse->{"first_lhs"}B= $lhs
ABresult
1X1
011
000
1113 96 local $Marpa::R3::Internal::SUBGRAMMAR = $subgrammar;
1114  
1115 96 my $xrlid = xrl_create($parse, {
1116 lhs => $lhs,
1117 start => $start,
1118 length => $length,
1119 }
1120 );
1121 # description => qq{Empty rule for <$lhs>},
1122 95 my %rule = (
1123 lhs => $lhs,
1124 start => $start,
1125 length => $length,
1126 rhs => [],
1127 xrlid => $xrlid,
1128 );
1129 95 my $adverb_list = $raw_adverb_list->evaluate($parse);
1130  
1131 95 my $default_adverbs = $parse->{default_adverbs}->{$subgrammar};
1132  
1133 95 my $action;
1134 my $blessing;
1135 95 my $naming;
1136 95 my $rank;
1137 95 my $null_ranking;
1138 95 ADVERB: for my $key ( keys %{$adverb_list} ) {
1139 30 my $value = $adverb_list->{$key};
1140 30 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 30 0 30
1141 30 $action = $adverb_list->{$key};
1142 30 next ADVERB;
1143 }
1144 0 ▶ if ( $key eq 'bless' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless") 0 0 0
1145 0 $blessing = $adverb_list->{$key};
1146 0 next ADVERB;
1147 }
1148 0 ▶ if ( $key eq 'name' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "name") 0 0 0
1149 0 $naming = $adverb_list->{$key};
1150 0 next ADVERB;
1151 }
1152 0 ▶ if ( $key eq 'null_ranking' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "null_ranking") 0 0 0
1153 0 $null_ranking = $adverb_list->{$key};
1154 0 next ADVERB;
1155 }
1156 0 ▶ if ( $key eq 'rank' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "rank") 0 0 0
1157 0 $rank = $adverb_list->{$key};
1158 0 next ADVERB;
1159 }
1160 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1161 0 die qq{Adverb "$key" not allowed in an empty rule\n},
1162 ' Rule was ', $parse->substring( $start, $length ), "\n";
1163 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
1164  
1165 95 ▶ $action //= $default_adverbs->{action};
Condition100%3/3
$action //= $default_adverbs->{"action"}
l!l&&r!l&&!r
303431
MC/DC100%2/2
$action //= $default_adverbs->{"action"}
$action $default_adverbs->{"action"}
Truth table100%3/3
A //= B
A= $actionB= $default_adverbs->{"action"}
ABresult
1X1
011
000
1166 95 ▶ if ( defined $action ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $action) 64 31 95
1167 64 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 64 64
1168 qq{actions not allowed in lexical rules (rule's LHS was "$lhs")}
1169 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1170 64 $rule{action} = $action;
1171 } ## end if ( defined $action )
1172  
1173 95 ▶ $null_ranking //= $default_adverbs->{null_ranking};
Condition33%1/3
$null_ranking //= $default_adverbs->{"null_ranking"}
l!l&&r!l&&!r
0095
MC/DC0%0/2
$null_ranking //= $default_adverbs->{"null_ranking"}
$null_ranking $default_adverbs->{"null_ranking"}
Truth table33%1/3
A //= B
A= $null_rankingB= $default_adverbs->{"null_ranking"}
ABresult
1X1
011
000
1174 95 ▶ if ( defined $null_ranking ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $null_ranking) 0 95 95
1175 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1176 qq{null-ranking not allowed in lexical rules (rule's LHS was "$lhs")}
1177 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1178 0 $rule{null_ranking} = $null_ranking;
1179 } ## end if ( defined $null_ranking )
1180  
1181 95 ▶ $rank //= $default_adverbs->{rank};
Condition33%1/3
$rank //= $default_adverbs->{"rank"}
l!l&&r!l&&!r
0095
MC/DC0%0/2
$rank //= $default_adverbs->{"rank"}
$rank $default_adverbs->{"rank"}
Truth table33%1/3
A //= B
A= $rankB= $default_adverbs->{"rank"}
ABresult
1X1
011
000
1182 95 ▶ if ( defined $rank ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $rank) 0 95 95
1183 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1184 qq{ranks not allowed in lexical rules (rule's LHS was "$lhs")}
1185 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1186 0 $rule{rank} = $rank;
1187 } ## end if ( defined $rank )
1188  
1189 95 ▶ $blessing //= $default_adverbs->{bless};
Condition33%1/3
$blessing //= $default_adverbs->{"bless"}
l!l&&r!l&&!r
0095
MC/DC0%0/2
$blessing //= $default_adverbs->{"bless"}
$blessing $default_adverbs->{"bless"}
Truth table33%1/3
A //= B
A= $blessingB= $default_adverbs->{"bless"}
ABresult
1X1
011
000
1190 95 ▶ if ( defined $blessing
Branch: 1 branch
BranchTrueFalseTotal
if (defined $blessing and substr($subgrammar, 0, 1) eq "l") 0 95 95
Condition33%1/3
defined $blessing and substr($subgrammar, 0, 1) eq "l"
!ll&&!rl&&r
9500
MC/DC0%0/2
defined $blessing and substr($subgrammar, 0, 1) eq "l"
defined $blessing substr($subgrammar, 0, 1) eq "l"
Truth table33%1/3
A and B
A= defined $blessingB= substr($subgrammar, 0, 1) eq "l"
ABresult
0X0
100
111
1191 and ( substr $subgrammar, 0, 1 ) eq 'l' )
1192 {
1193 0 Marpa::R3::exception(
1194 qq{bless option not allowed in lexical rules (rule's LHS was "$lhs")}
1195 );
1196 }
1197 95 $parse->bless_hash_rule( \%rule, $blessing, $naming, $lhs );
1198  
1199 95 $parse->symbol_assign_ordinary($lhs, $subgrammar);
1200 95 my $wrl = $parse->xpr_create( \%rule, $subgrammar );
1201 # mask not needed
1202 95 push @{ $parse->{rules}->{$subgrammar} }, $wrl;
1203  
1204 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1205 95 return undef;
1206 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::empty_rule::evaluate
1207  
1208 89 ▶sub Marpa::R3::Internal::MetaAST_Nodes::lexeme_rule::evaluate {
Subroutine evaluate: called CC=16 SCAR=31.3
1209 89 my ( $values, $parse ) = @_;
1210 89 my ( $start, $length, $symbol, $unevaluated_adverb_list ) = @{$values};
1211  
1212 89 my $symbol_name = $symbol->name();
1213 89 my $declarations = $parse->{lexeme_declarations}->{$symbol_name};
1214 89 ▶ if ( defined $declarations ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $declarations) 0 89 89
1215 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1216 0 die "Duplicate lexeme rule for <$symbol_name>\n",
1217 " Only one lexeme rule is allowed for each symbol\n",
1218 " Location was line $line, column $column\n",
1219 ' Rule was ', $parse->substring( $start, $length ), "\n";
1220 } ## end if ( defined $declarations )
1221  
1222 89 my $adverb_list = $unevaluated_adverb_list->evaluate();
1223 89 my %declarations;
1224 89 ADVERB: for my $key ( keys %{$adverb_list} ) {
1225 143 my $raw_value = $adverb_list->{$key};
1226 143 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 0 143 143
1227 0 $declarations{$key} = $raw_value;
1228 0 next ADVERB;
1229 }
1230 143 ▶ if ( $key eq 'blessing' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "blessing") 0 143 143
1231 0 $declarations{$key} = $raw_value;
1232 0 next ADVERB;
1233 }
1234 143 ▶ if ( $key eq 'eager' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "eager") 19 124 143
1235 19 ▶ $declarations{$key} = 1 if $raw_value;
Branch: 1 branch
BranchTrueFalseTotal
if $raw_value 18 1 19
1236 19 next ADVERB;
1237 }
1238 124 ▶ if ( $key eq 'event' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "event") 61 63 124
1239 61 $declarations{$key} = $raw_value;
1240 61 next ADVERB;
1241 }
1242 63 ▶ if ( $key eq 'pause' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "pause") 61 2 63
1243 61 ▶ if ( $raw_value eq 'before' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($raw_value eq "before") 12 49 61
1244 12 $declarations{$key} = -1;
1245 12 next ADVERB;
1246 }
1247 49 ▶ if ( $raw_value eq 'after' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($raw_value eq "after") 49 0 49
1248 49 $declarations{$key} = 1;
1249 49 next ADVERB;
1250 }
1251 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1252 0 die qq{Bad value for "pause" adverb: "$raw_value"},
1253 " Location was line $line, column $column\n",
1254 ' Rule was ', $parse->substring( $start, $length ), "\n";
1255 } ## end if ( $key eq 'pause' )
1256 2 ▶ if ( $key eq 'priority' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "priority") 2 0 2
1257 2 $declarations{$key} = $raw_value + 0;
1258 2 next ADVERB;
1259 }
1260 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1261 0 die qq{"$key" adverb not allowed in lexeme rule"\n},
1262 " Location was line $line, column $column\n",
1263 ' Rule was ', $parse->substring( $start, $length ), "\n";
1264 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
1265 89 ▶ if ( exists $declarations{'event'} and not exists $declarations{'pause'} )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $declarations{"event"} and not exists $declarations{"pause"}) 0 89 89
Condition66%2/3
exists $declarations{"event"} and not exists $declarations{"pause"}
!ll&&!rl&&r
28610
MC/DC0%0/2
exists $declarations{"event"} and not exists $declarations{"pause"}
exists $declarations{"event"} not exists $declarations{"pause"}
Truth table66%2/3
A and not(B)
A= exists $declarations{"event"}B= not exists $declarations{"pause"}
ABresult
0X0
100
111
1266 {
1267 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1268 0 die
1269 qq{"event" adverb not allowed without "pause" adverb in lexeme rule"\n},
1270 " Location was line $line, column $column\n",
1271 ' Rule was ', $parse->substring( $start, $length ), "\n";
1272 } ## end if ( exists $declarations{'event'} and not exists $declarations...)
1273 89 ▶ if ( exists $declarations{'pause'} and not exists $declarations{'event'} )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $declarations{"pause"} and not exists $declarations{"event"}) 0 89 89
Condition66%2/3
exists $declarations{"pause"} and not exists $declarations{"event"}
!ll&&!rl&&r
28610
MC/DC0%0/2
exists $declarations{"pause"} and not exists $declarations{"event"}
exists $declarations{"pause"} not exists $declarations{"event"}
Truth table66%2/3
A and not(B)
A= exists $declarations{"pause"}B= not exists $declarations{"event"}
ABresult
0X0
100
111
1274 {
1275 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1276 0 die
1277 qq{"pause" adverb not allowed without "event" adverb in lexeme rule"\n},
1278 qq{ Events must be named with the "event" adverb\n},
1279 " Location was line $line, column $column\n",
1280 ' Rule was ', $parse->substring( $start, $length ), "\n";
1281 } ## end if ( exists $declarations{'event'} and not exists $declarations...)
1282 89 $parse->{lexeme_declarations}->{$symbol_name} = \%declarations;
1283 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1284 89 return undef;
1285 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::lexeme_rule::evaluate
1286  
1287 12 ▶sub Marpa::R3::Internal::MetaAST_Nodes::statements::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1288 12 my ( $data, $parse ) = @_;
1289 12 my ( undef, undef, @statement_list ) = @{$data};
1290 12 map { $_->evaluate($parse) } @statement_list;
1291 12 return undef;
1292 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::statements::evaluate
1293  
1294 2683 ▶sub Marpa::R3::Internal::MetaAST_Nodes::statement::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1295 2683 my ( $data, $parse ) = @_;
1296 2683 my ( undef, undef, $child ) = @{$data};
1297 2683 $child->evaluate($parse);
1298 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1299 2678 return undef;
1300 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::statement::evaluate
1301  
1302 25 ▶sub Marpa::R3::Internal::MetaAST_Nodes::null_statement::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1303 25 return undef;
1304 }
1305  
1306 12 ▶sub Marpa::R3::Internal::MetaAST_Nodes::statement_group::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1307 12 my ( $data, $parse ) = @_;
1308 12 my ( undef, undef, $statements ) = @{$data};
1309 12 $statements->evaluate($parse);
1310 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1311 12 return undef;
1312 }
1313  
1314 114 ▶sub Marpa::R3::Internal::MetaAST_Nodes::start_rule::evaluate {
Subroutine evaluate: called CC=2 SCAR=7.5
1315 114 my ( $values, $parse ) = @_;
1316 114 my ( $start, $length, $symbol ) = @{$values};
1317 114 ▶ if ( defined $parse->{'start_lhs'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $parse->{"start_lhs"}) 0 114 114
1318 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1319 0 die qq{There are two start rules\n},
1320 qq{ That is not allowed\n},
1321 ' The second start rule is ',
1322 $parse->substring( $start, $length ),
1323 "\n",
1324 " Problem occurred at line $line, column $column\n";
1325 } ## end if ( defined $parse->{'start_lhs'} )
1326 114 $parse->{'start_lhs'} = $symbol->name($parse);
1327 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1328 114 return undef;
1329 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::start_rule::evaluate
1330  
1331 197 ▶sub Marpa::R3::Internal::MetaAST_Nodes::discard_rule::evaluate {
Subroutine evaluate: called CC=7 SCAR=19.5
1332 197 my ( $values, $parse ) = @_;
1333 197 my ( $start, $length, $symbol, $raw_adverb_list ) = @{$values};
1334  
1335 197 local $Marpa::R3::Internal::SUBGRAMMAR = 'l0';
1336 197 my $discard_lhs = '[:discard:]';
1337 197 my $symbol_data = {
1338 dsl_form => $discard_lhs,
1339 name_source => 'internal',
1340 };
1341 197 $parse->xsy_assign( $discard_lhs, $symbol_data );
1342 197 $parse->symbol_names_set( $discard_lhs, 'l0', { xsy => $discard_lhs } );
1343  
1344 197 my $rhs = $symbol->names($parse);
1345 197 my $discard_symbol = $rhs->[0];
1346 197 my $rhs_as_event = $symbol->event_name($parse);
1347 197 my $adverb_list = $raw_adverb_list->evaluate($parse);
1348 197 my $event;
1349 my $eager;
1350 197 ADVERB: for my $key ( keys %{$adverb_list} ) {
1351 53 my $value = $adverb_list->{$key};
1352 53 ▶ if ( $key eq 'eager' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "eager") 2 51 53
1353 2 ▶ $eager = 1 if $value;
Branch: 1 branch
BranchTrueFalseTotal
if $value 2 0 2
1354 2 next ADVERB;
1355 }
1356 51 ▶ if ( $key eq 'event' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "event") 51 0 51
1357 51 $event = $value;
1358 51 next ADVERB;
1359 }
1360 Marpa::R3::exception(
1361 0 qq{"$key" adverb not allowed with discard rule"});
1362 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
1363  
1364 197 my $discard_symbol_data = $parse->discard_symbol_assign($discard_symbol);
1365 197 ▶ if ($eager) {
Branch: 1 branch
BranchTrueFalseTotal
if ($eager) 2 195 197
1366 2 $discard_symbol_data->{eager} = $eager;
1367 }
1368  
1369 # Discard rule
1370 197 my %rule_hash = (
1371 lhs => $discard_lhs,
1372 rhs => [$discard_symbol],
1373 start => $start,
1374 length => $length,
1375 symbol_as_event => $rhs_as_event
1376 );
1377 197 ▶ $rule_hash{event} = $event if defined $event;
Branch: 1 branch
BranchTrueFalseTotal
if defined $event 51 146 197
1378 197 my $wrl = $parse->xpr_create( \%rule_hash, 'l0' );
1379 197 push @{ $parse->{rules}->{l0} }, $wrl;
1380 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1381 197 return undef;
1382 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::discard_rule::evaluate
1383  
1384 322 ▶sub Marpa::R3::Internal::MetaAST_Nodes::quantified_rule::evaluate {
Subroutine evaluate: called CC=29 SCAR=37.1
1385 322 my ( $values, $parse ) = @_;
1386 my ( $start, $length, $lhs, $op_declare, $rhs, $quantifier,
1387 $proto_adverb_list )
1388 322 = @{$values};
1389  
1390 322 ▶ my $subgrammar = $op_declare->op() eq q{::=} ? 'g1' : 'l0';
Branch: 1 branch
BranchTrueFalseTotal
$op_declare->op eq '::=' ? : 96 226 322
1391  
1392 322 my $lhs_name = $lhs->name($parse);
1393 322 ▶ $parse->{'first_lhs'} //= $lhs_name if $subgrammar eq 'g1';
Branch: 1 branch
BranchTrueFalseTotal
if $subgrammar eq "g1" 96 226 322
Condition66%2/3
$parse->{"first_lhs"} //= $lhs_name
l!l&&r!l&&!r
52440
MC/DC0%0/2
$parse->{"first_lhs"} //= $lhs_name
$parse->{"first_lhs"} $lhs_name
Truth table66%2/3
A //= B
A= $parse->{"first_lhs"}B= $lhs_name
ABresult
1X1
011
000
1394 322 local $Marpa::R3::Internal::SUBGRAMMAR = $subgrammar;
1395  
1396 322 my $quantifier_string = $quantifier->evaluate($parse);
1397 322 my $xrlid = xrl_create($parse, {
1398 lhs => $lhs_name,
1399 start => $start,
1400 length => $length,
1401 }
1402 );
1403  
1404 322 my $adverb_list = $proto_adverb_list->evaluate($parse);
1405 322 my $default_adverbs = $parse->{default_adverbs}->{$subgrammar};
1406  
1407 # Some properties of the sequence rule will not be altered
1408 # no matter how complicated this gets
1409 322 ▶ my %sequence_rule = (
Branch: 1 branch
BranchTrueFalseTotal
$quantifier_string eq '+' ? : 245 77 322
1410 start => $start,
1411 length => $length,
1412 xrlid => $xrlid,
1413 rhs => [ $rhs->name($parse) ],
1414 min => ( $quantifier_string eq q{+} ? 1 : 0 )
1415 );
1416  
1417 322 my $action;
1418 my $blessing;
1419 322 my $naming;
1420 322 my $separator;
1421 322 my $proper;
1422 322 my $rank;
1423 322 my $null_ranking;
1424 322 ADVERB: for my $key ( keys %{$adverb_list} ) {
1425 71 my $value = $adverb_list->{$key};
1426 71 ▶ if ( $key eq 'action' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "action") 44 27 71
1427 44 $action = $adverb_list->{$key};
1428 44 next ADVERB;
1429 }
1430 27 ▶ if ( $key eq 'bless' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "bless") 4 23 27
1431 4 $blessing = $adverb_list->{$key};
1432 4 next ADVERB;
1433 }
1434 23 ▶ if ( $key eq 'name' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "name") 0 23 23
1435 0 $naming = $adverb_list->{$key};
1436 0 next ADVERB;
1437 }
1438 23 ▶ if ( $key eq 'proper' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "proper") 4 19 23
1439 4 $proper = $adverb_list->{$key};
1440 4 next ADVERB;
1441 }
1442 19 ▶ if ( $key eq 'rank' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "rank") 0 19 19
1443 0 $rank = $adverb_list->{$key};
1444 0 next ADVERB;
1445 }
1446 19 ▶ if ( $key eq 'null_ranking' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "null_ranking") 0 19 19
1447 0 $null_ranking = $adverb_list->{$key};
1448 0 next ADVERB;
1449 }
1450 19 ▶ if ( $key eq 'separator' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key eq "separator") 19 0 19
1451 19 $separator = $adverb_list->{$key};
1452 19 next ADVERB;
1453 }
1454 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1455 0 die qq{Adverb "$key" not allowed in quantified rule\n},
1456 ' Rule was ', $parse->substring( $start, $length ), "\n";
1457 } ## end ADVERB: for my $key ( keys %{$adverb_list} )
1458  
1459 # mask not needed
1460 322 $sequence_rule{lhs} = $lhs_name;
1461  
1462 322 ▶ $sequence_rule{separator} = $separator
Branch: 1 branch
BranchTrueFalseTotal
if defined $separator 19 303 322
1463 if defined $separator;
1464 322 ▶ $sequence_rule{proper} = $proper if defined $proper;
Branch: 1 branch
BranchTrueFalseTotal
if defined $proper 4 318 322
1465  
1466 322 ▶ $action //= $default_adverbs->{action};
Condition100%3/3
$action //= $default_adverbs->{"action"}
l!l&&r!l&&!r
4437241
MC/DC100%2/2
$action //= $default_adverbs->{"action"}
$action $default_adverbs->{"action"}
Truth table100%3/3
A //= B
A= $actionB= $default_adverbs->{"action"}
ABresult
1X1
011
000
1467 322 ▶ if ( defined $action ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $action) 81 241 322
1468 81 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 81 81
1469 qq{actions not allowed in lexical rules (rule's LHS was "$lhs")}
1470 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1471 81 $sequence_rule{action} = $action;
1472 } ## end if ( defined $action )
1473  
1474 322 ▶ $null_ranking //= $default_adverbs->{null_ranking};
Condition33%1/3
$null_ranking //= $default_adverbs->{"null_ranking"}
l!l&&r!l&&!r
00322
MC/DC0%0/2
$null_ranking //= $default_adverbs->{"null_ranking"}
$null_ranking $default_adverbs->{"null_ranking"}
Truth table33%1/3
A //= B
A= $null_rankingB= $default_adverbs->{"null_ranking"}
ABresult
1X1
011
000
1475 322 ▶ if ( defined $null_ranking ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $null_ranking) 0 322 322
1476 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1477 qq{null-ranking not allowed in lexical rules (rule's LHS was "$lhs")}
1478 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1479 0 $sequence_rule{null_ranking} = $null_ranking;
1480 } ## end if ( defined $null_ranking )
1481  
1482 322 ▶ $rank //= $default_adverbs->{rank};
Condition33%1/3
$rank //= $default_adverbs->{"rank"}
l!l&&r!l&&!r
00322
MC/DC0%0/2
$rank //= $default_adverbs->{"rank"}
$rank $default_adverbs->{"rank"}
Truth table33%1/3
A //= B
A= $rankB= $default_adverbs->{"rank"}
ABresult
1X1
011
000
1483 322 ▶ if ( defined $rank ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $rank) 0 322 322
1484 0 ▶ Marpa::R3::exception(
Branch: 1 branch
BranchTrueFalseTotal
if substr($subgrammar, 0, 1) eq "l" 0 0 0
1485 qq{ranks not allowed in lexical rules (rule's LHS was "$lhs")}
1486 ) if ( substr $subgrammar, 0, 1 ) eq 'l';
1487 0 $sequence_rule{rank} = $rank;
1488 } ## end if ( defined $rank )
1489  
1490 322 ▶ $blessing //= $default_adverbs->{bless};
Condition100%3/3
$blessing //= $default_adverbs->{"bless"}
l!l&&r!l&&!r
44314
MC/DC100%2/2
$blessing //= $default_adverbs->{"bless"}
$blessing $default_adverbs->{"bless"}
Truth table100%3/3
A //= B
A= $blessingB= $default_adverbs->{"bless"}
ABresult
1X1
011
000
1491 322 ▶ if ( defined $blessing and ( substr $subgrammar, 0, 1 ) eq 'l' )
Branch: 1 branch
BranchTrueFalseTotal
if (defined $blessing and substr($subgrammar, 0, 1) eq "l") 0 322 322
Condition66%2/3
defined $blessing and substr($subgrammar, 0, 1) eq "l"
!ll&&!rl&&r
31480
MC/DC0%0/2
defined $blessing and substr($subgrammar, 0, 1) eq "l"
defined $blessing substr($subgrammar, 0, 1) eq "l"
Truth table66%2/3
A and B
A= defined $blessingB= substr($subgrammar, 0, 1) eq "l"
ABresult
0X0
100
111
1492 {
1493 0 Marpa::R3::exception(
1494 qq{bless option not allowed in lexical rules (rule's LHS was "$lhs")}
1495 );
1496 }
1497 322 $parse->symbol_assign_ordinary($_, $subgrammar) for $lhs_name, @{$sequence_rule{rhs}};
1498 322 ▶ $parse->symbol_assign_ordinary($separator, $subgrammar) if defined $separator;
Branch: 1 branch
BranchTrueFalseTotal
if defined $separator 19 303 322
1499 322 $parse->bless_hash_rule( \%sequence_rule, $blessing, $naming, $lhs_name );
1500  
1501 322 my $wrl = $parse->xpr_create( \%sequence_rule, $subgrammar );
1502 322 push @{ $parse->{rules}->{$subgrammar} }, $wrl;
1503 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1504 322 return undef;
1505  
1506 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::quantified_rule::evaluate
1507  
1508 sub Marpa::R3::Internal::MetaAST_Nodes::completion_event_declaration::evaluate
1509 60 ▶{
Subroutine evaluate: called CC=3 SCAR=11.3
1510 60 my ( $values, $parse ) = @_;
1511 60 my ( $start, $length, $raw_event, $raw_symbol_name ) = @{$values};
1512 60 my $symbol_name = $raw_symbol_name->name();
1513 60 ▶ my $completion_events = $parse->{completion_events} //= {};
Condition100%2/2
$parse->{"completion_events"} //= {}
l!l
4911
MC/DC100%1/1
$parse->{"completion_events"} //= {}
$parse->{"completion_events"}
Truth table100%2/2
A
A= $parse->{"completion_events"}
Aresult
11
00
1514 60 ▶ if ( defined $completion_events->{$symbol_name} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $completion_events->{$symbol_name}) 0 60 60
1515 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1516 0 die qq{Completion event for symbol "$symbol_name" declared twice\n},
1517 qq{ That is not allowed\n},
1518 ' Second declaration was ', $parse->substring( $start, $length ),
1519 "\n",
1520 " Problem occurred at line $line, column $column\n";
1521 } ## end if ( defined $completion_events->{$symbol_name} )
1522 60 $completion_events->{$symbol_name} = $raw_event->event();
1523 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1524 60 return undef;
1525 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::completion_event_declaration::evaluate
1526  
1527 46 ▶sub Marpa::R3::Internal::MetaAST_Nodes::nulled_event_declaration::evaluate {
Subroutine evaluate: called CC=3 SCAR=11.3
1528 46 my ( $values, $parse ) = @_;
1529 46 my ( $start, $length, $raw_event, $raw_symbol_name ) = @{$values};
1530 46 my $symbol_name = $raw_symbol_name->name();
1531 46 ▶ my $nulled_events = $parse->{nulled_events} //= {};
Condition100%2/2
$parse->{"nulled_events"} //= {}
l!l
406
MC/DC100%1/1
$parse->{"nulled_events"} //= {}
$parse->{"nulled_events"}
Truth table100%2/2
A
A= $parse->{"nulled_events"}
Aresult
11
00
1532 46 ▶ if ( defined $nulled_events->{$symbol_name} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $nulled_events->{$symbol_name}) 0 46 46
1533 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1534 0 die qq{nulled event for symbol "$symbol_name" declared twice\n},
1535 qq{ That is not allowed\n},
1536 ' Second declaration was ', $parse->substring( $start, $length ),
1537 "\n",
1538 " Problem occurred at line $line, column $column\n";
1539 } ## end if ( defined $nulled_events->{$symbol_name} )
1540 46 $nulled_events->{$symbol_name} = $raw_event->event();
1541 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1542 46 return undef;
1543 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::nulled_event_declaration::evaluate
1544  
1545 sub Marpa::R3::Internal::MetaAST_Nodes::prediction_event_declaration::evaluate
1546 55 ▶{
Subroutine evaluate: called CC=3 SCAR=11.3
1547 55 my ( $values, $parse ) = @_;
1548 55 my ( $start, $length, $raw_event, $raw_symbol_name ) = @{$values};
1549 55 my $symbol_name = $raw_symbol_name->name();
1550 55 ▶ my $prediction_events = $parse->{prediction_events} //= {};
Condition100%2/2
$parse->{"prediction_events"} //= {}
l!l
478
MC/DC100%1/1
$parse->{"prediction_events"} //= {}
$parse->{"prediction_events"}
Truth table100%2/2
A
A= $parse->{"prediction_events"}
Aresult
11
00
1551 55 ▶ if ( defined $prediction_events->{$symbol_name} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $prediction_events->{$symbol_name}) 0 55 55
1552 0 my ( $line, $column ) = $parse->{meta_recce}->line_column(undef, $start);
1553 0 die qq{prediction event for symbol "$symbol_name" declared twice\n},
1554 qq{ That is not allowed\n},
1555 ' Second declaration was ', $parse->substring( $start, $length ),
1556 "\n",
1557 " Problem occurred at line $line, column $column\n";
1558 } ## end if ( defined $prediction_events->{$symbol_name} )
1559 55 $prediction_events->{$symbol_name} = $raw_event->event();
1560 ## no critic(Subroutines::ProhibitExplicitReturnUndef)
1561 55 return undef;
1562 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::prediction_event_declaration::evaluate
1563  
1564 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::alternatives::evaluate {
Subroutine evaluate: not called CC=1 SCAR=6.9
1565 0 my ( $values, $parse ) = @_;
1566 0 return bless [ map { $_->evaluate( $_, $parse ) } @{$values} ],
1567 ref $values;
1568 }
1569  
1570 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::alternative::evaluate {
Subroutine evaluate: not called CC=2 SCAR=17.9
1571 0 my ( $values, $parse ) = @_;
1572 0 my ( $start, $length, $rhs, $adverbs ) = @{$values};
1573 0 my $alternative = eval {
1574 Marpa::R3::Internal::MetaAST::Proto_Alternative->combine(
1575 0 map { $_->evaluate($parse) } $rhs, $adverbs );
1576 };
1577 0 ▶ if ( not $alternative ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($alternative) 0 0 0
1578 0 Marpa::R3::exception(
1579 $EVAL_ERROR, "\n",
1580 q{ Alternative involved was },
1581 $parse->substring( $start, $length )
1582 );
1583 } ## end if ( not $alternative )
1584 0 return $alternative;
1585 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::alternative::evaluate
1586  
1587 197 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::names {
Subroutine names: called CC=1 SCAR=0.0
1588 197 my ( $values, $parse ) = @_;
1589 197 my ( undef, undef, $symbol ) = @{$values};
1590 197 return $symbol->names($parse);
1591 }
1592  
1593 341 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::name {
Subroutine name: called CC=1 SCAR=0.0
1594 341 my ( $values, $parse ) = @_;
1595 341 my ( undef, undef, $symbol ) = @{$values};
1596 341 return $symbol->name($parse);
1597 }
1598  
1599 197 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::event_name {
Subroutine event_name: called CC=1 SCAR=0.0
1600 197 my ( $values, $parse ) = @_;
1601 197 my ( undef, undef, $symbol ) = @{$values};
1602 197 return $symbol->event_name($parse);
1603 }
1604  
1605 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::literal {
Subroutine literal: not called CC=1 SCAR=6.9
1606 0 my ( $values, $parse ) = @_;
1607 0 my ( $start, $length ) = @{$values};
1608 0 return $parse->substring($start, $length);
1609 }
1610  
1611 2167 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1612 2167 my ( $values, $parse ) = @_;
1613 2167 my ( undef, undef, $symbol ) = @{$values};
1614 2167 return Marpa::R3::Internal::MetaAST::Symbol_List->new(
1615 $symbol->name($parse) );
1616 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::single_symbol::evaluate
1617  
1618 0 ▶sub Marpa::R3::Internal::MetaAST_Nodes::Symbol::evaluate {
Subroutine evaluate: not called CC=1 SCAR=6.9
1619 0 my ( $values, $parse ) = @_;
1620 0 my ( undef, undef, $symbol ) = @{$values};
1621 0 return $symbol->evaluate($parse);
1622 }
1623  
1624 2279 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol::name {
Subroutine name: called CC=1 SCAR=0.0
1625 2279 my ( $self, $parse ) = @_;
1626 2279 return $self->[2]->name($parse);
1627 }
1628  
1629 179 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol::event_name {
Subroutine event_name: called CC=1 SCAR=0.0
1630 179 my ( $self, $parse ) = @_;
1631 179 return $self->[2]->name($parse);
1632 }
1633  
1634 179 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol::names {
Subroutine names: called CC=1 SCAR=0.0
1635 179 my ( $self, $parse ) = @_;
1636 179 return $self->[2]->names($parse);
1637 }
1638  
1639 4664 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol_name::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1640 4664 my ($self) = @_;
1641 4664 return $self->[2];
1642 }
1643  
1644 4664 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol_name::name {
Subroutine name: called CC=1 SCAR=0.0
1645 4664 my ( $self, $parse ) = @_;
1646 4664 return $self->evaluate($parse)->name($parse);
1647 }
1648  
1649 179 ▶sub Marpa::R3::Internal::MetaAST_Nodes::symbol_name::names {
Subroutine names: called CC=1 SCAR=0.0
1650 179 my ( $self, $parse ) = @_;
1651 179 return [ $self->name($parse) ];
1652 }
1653  
1654 2721 ▶sub Marpa::R3::Internal::MetaAST_Nodes::adverb_list::evaluate {
Subroutine evaluate: called CC=2 SCAR=6.9
1655 2721 my ( $data, $parse ) = @_;
1656 2721 my ( undef, undef, $adverb_list_items ) = @{$data};
1657 2721 ▶ return undef if not defined $adverb_list_items;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $adverb_list_items 1898 823 2721
1658 823 return $adverb_list_items->evaluate($parse);
1659 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::adverb_list::evaluate
1660  
1661 6 ▶sub Marpa::R3::Internal::MetaAST_Nodes::null_adverb::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1662 6 return {};
1663 }
1664  
1665 823 ▶sub Marpa::R3::Internal::MetaAST_Nodes::adverb_list_items::evaluate {
Subroutine evaluate: called CC=1 SCAR=0.0
1666 823 my ( $data, $parse ) = @_;
1667 823 my ( undef, undef, @raw_items ) = @{$data};
1668 823 my (@adverb_items) = map { $_->evaluate($parse) } @raw_items;
1669 823 return Marpa::R3::Internal::MetaAST::Proto_Alternative->combine(
1670 @adverb_items);
1671 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::adverb_list::evaluate
1672  
1673 18 ▶sub Marpa::R3::Internal::MetaAST_Nodes::character_class::event_name {
Subroutine event_name: called CC=1 SCAR=0.0
1674 18 my ( $data, $parse ) = @_;
1675 18 my ( $start, $length ) = @{$data};
1676 18 return $parse->substring( $start, $length );
1677 }
1678  
1679 18 ▶sub Marpa::R3::Internal::MetaAST_Nodes::character_class::names {
Subroutine names: called CC=1 SCAR=0.0
1680 18 my ( $self, $parse ) = @_;
1681 18 return [ $self->name($parse) ];
1682 }
1683  
1684 450 ▶sub Marpa::R3::Internal::MetaAST_Nodes::character_class::name {
Subroutine name: called CC=1 SCAR=0.0
1685 450 my ( $self, $parse ) = @_;
1686 450 return $self->evaluate($parse)->name($parse);
1687 }
1688  
1689 450 ▶sub Marpa::R3::Internal::MetaAST_Nodes::character_class::evaluate {
Subroutine evaluate: called CC=2 SCAR=6.9
1690 450 my ( $values, $parse ) = @_;
1691 450 my ( $start, $length, $character_class ) = @{$values};
1692 450 my $subgrammar = $Marpa::R3::Internal::SUBGRAMMAR;
1693 450 ▶ if ( ( substr $subgrammar, 0, 1 ) eq 'l' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($subgrammar, 0, 1) eq "l") 433 17 450
1694 433 return Marpa::R3::Internal::MetaAST::Symbol_List->char_class_to_symbol(
1695 $parse, $character_class );
1696 }
1697  
1698 # If here, in G1
1699 # Character classes and strings always go into L0, for now
1700 17 my $lexer_symbol = do {
1701 17 local $Marpa::R3::Internal::SUBGRAMMAR = 'l0';
1702 17 Marpa::R3::Internal::MetaAST::Symbol_List->char_class_to_symbol( $parse,
1703 $character_class );
1704 };
1705 17 my $lexical_lhs = $parse->internal_lexeme($character_class);
1706 17 my $lexical_rhs = $lexer_symbol->names($parse);
1707 17 my %lexical_rule = (
1708 start => $start,
1709 length => $length,
1710 lhs => $lexical_lhs,
1711 rhs => $lexical_rhs,
1712 mask => [1],
1713 );
1714 17 my $wrl = $parse->xpr_create( \%lexical_rule, 'l0' );
1715 17 push @{ $parse->{rules}->{l0} }, $wrl;
1716 17 my $g1_symbol =
1717 Marpa::R3::Internal::MetaAST::Symbol_List->new($lexical_lhs);
1718 17 return $g1_symbol;
1719 }
1720  
1721 842 ▶sub Marpa::R3::Internal::MetaAST_Nodes::single_quoted_string::evaluate {
Subroutine evaluate: called CC=5 SCAR=16.1
1722 842 my ( $values, $parse ) = @_;
1723 842 my ( $start, $length, $string ) = @{$values};
1724 842 my @symbols = ();
1725  
1726 842 my $end_of_string = rindex $string, q{'};
1727 842 my $unmodified_string = substr $string, 0, $end_of_string+1;
1728 842 my $raw_flags = substr $string, $end_of_string+1;
1729 842 my $flags = Marpa::R3::Internal::MetaAST::flag_string_to_flags($raw_flags);
1730 842 my $subgrammar = $Marpa::R3::Internal::SUBGRAMMAR;
1731  
1732 # If we are currently in a lexical grammar, the strings go there
1733 # If we are currently in G1, the strings always go into L0
1734 842 ▶ my $lexical_grammar = $subgrammar eq 'g1' ? 'l0' : $subgrammar;
Branch: 1 branch
BranchTrueFalseTotal
$subgrammar eq 'g1' ? : 335 507 842
1735  
1736 842 for my $char_class (
1737 1304 map { '[' . ( quotemeta $_ ) . ']' . $flags } split //xms,
1738 substr $unmodified_string,
1739 1, -1
1740 )
1741 {
1742 1304 local $Marpa::R3::Internal::SUBGRAMMAR = $lexical_grammar;
1743 1304 my $symbol =
1744 Marpa::R3::Internal::MetaAST::Symbol_List->char_class_to_symbol(
1745 $parse, $char_class );
1746 1304 push @symbols, $symbol;
1747 } ## end for my $char_class ( map { '[' . ( quotemeta $_ ) . ']'...})
1748 842 my $list = Marpa::R3::Internal::MetaAST::Symbol_List->combine(@symbols);
1749 842 ▶ return $list if $Marpa::R3::Internal::SUBGRAMMAR ne 'g1';
Branch: 1 branch
BranchTrueFalseTotal
if $Marpa::R3::Internal::SUBGRAMMAR ne "g1" 507 335 842
1750 335 my $lexical_lhs = $parse->{lexeme_for_string}->{$string};
1751 335 ▶ if (not defined $lexical_lhs) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $lexical_lhs) 279 56 335
1752 279 $lexical_lhs = $parse->internal_lexeme($string);
1753 279 $parse->{lexeme_for_string}->{$string}= $lexical_lhs;
1754 279 my $lexical_rhs = $list->names($parse);
1755 my %lexical_rule = (
1756 start => $start,
1757 length => $length,
1758 lhs => $lexical_lhs,
1759 rhs => $lexical_rhs,
1760 # description => "Internal rule for single-quoted string $string",
1761 279 mask => [ map { ; 1 } @{$lexical_rhs} ],
1762 );
1763 279 my $wrl = $parse->xpr_create( \%lexical_rule, 'l0' );
1764 279 push @{ $parse->{rules}->{$lexical_grammar} }, $wrl;
1765 }
1766 335 my $g1_symbol =
1767 Marpa::R3::Internal::MetaAST::Symbol_List->new($lexical_lhs);
1768 335 return $g1_symbol;
1769 } ## end sub Marpa::R3::Internal::MetaAST_Nodes::single_quoted_string::evaluate
1770  
1771 package Marpa::R3::Internal::MetaAST::Symbol_List;
1772  
1773 104 ▶use English qw( -no_match_vars );
Subroutine BEGIN: called CC=1 SCAR=0.0
1774  
1775 4278 ▶sub new {
Subroutine new: called CC=1 SCAR=0.0
1776 4278 my ( $class, $name ) = @_;
1777 4278 return bless { names => [ q{} . $name ], mask => [1] }, $class;
1778 }
1779  
1780 5890 ▶sub combine {
Subroutine combine: called CC=1 SCAR=0.0
1781 5890 my ( $class, @lists ) = @_;
1782 5890 my $self = {};
1783 5890 $self->{names} = [ map { @{ $_->names() } } @lists ];
1784 5890 $self->{mask} = [ map { @{ $_->mask() } } @lists ];
1785 5890 return bless $self, $class;
1786 } ## end sub combine
1787  
1788 2601 ▶sub Marpa::R3::Internal::MetaAST::flag_string_to_flags {
Subroutine flag_string_to_flags: called CC=6 SCAR=18.0
1789 2601 my ($raw_flag_string) = @_;
1790 2601 ▶ return q{} if not $raw_flag_string;
Branch: 1 branch
BranchTrueFalseTotal
unless $raw_flag_string 2565 36 2601
1791 36 my @raw_flags = split m/:/xms, $raw_flag_string;
1792 36 my %flags = ();
1793 36 RAW_FLAG: for my $raw_flag (@raw_flags) {
1794 44 ▶ next RAW_FLAG if not $raw_flag;
Branch: 1 branch
BranchTrueFalseTotal
unless $raw_flag 8 36 44
1795 36 ▶ if ( $raw_flag eq 'i' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($raw_flag eq "i") 34 2 36
1796 34 $flags{'i'} = 1;
1797 34 next RAW_FLAG;
1798 }
1799 2 ▶ if ( $raw_flag eq 'ic' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($raw_flag eq "ic") 2 0 2
1800 2 $flags{'i'} = 1;
1801 2 next RAW_FLAG;
1802 }
1803 Carp::croak(
1804 0 qq{Bad flag for character class\n},
1805 qq{ Flag string was $raw_flag_string\n},
1806 qq{ Bad flag was $raw_flag\n}
1807 );
1808 } ## end RAW_FLAG: for my $raw_flag (@raw_flags)
1809 36 my $cooked_flags = join q{}, sort keys %flags;
1810 36 return $cooked_flags;
1811 } ## end sub flag_string_to_flags
1812  
1813 # Return the character class symbol name,
1814 # after ensuring everything is set up properly
1815 1759 ▶sub char_class_to_symbol {
Subroutine char_class_to_symbol: called CC=3 SCAR=11.0
1816 1759 my ( $class, $parse, $char_class ) = @_;
1817  
1818 1759 my $end_of_char_class = rindex $char_class, q{]};
1819 1759 my $unmodified_char_class = substr $char_class, 0, $end_of_char_class + 1;
1820 1759 my $raw_flags = substr $char_class, $end_of_char_class + 1;
1821 1759 my $flags = Marpa::R3::Internal::MetaAST::flag_string_to_flags($raw_flags);
1822 1759 my $subgrammar = $Marpa::R3::Internal::SUBGRAMMAR;
1823  
1824 # character class symbol name always start with TWO left square brackets
1825 1759 my $symbol_name = '[' . $unmodified_char_class . $flags . ']';
1826 1759 ▶ $parse->{character_classes} //= {};
Condition100%2/2
$parse->{"character_classes"} //= {}
l!l
1473286
MC/DC100%1/1
$parse->{"character_classes"} //= {}
$parse->{"character_classes"}
Truth table100%2/2
A
A= $parse->{"character_classes"}
Aresult
11
00
1827 1759 my $cc_hash = $parse->{character_classes};
1828 1759 my ( undef, $symbol ) = $cc_hash->{$symbol_name};
1829 1759 ▶ if ( not defined $symbol ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $symbol) 1759 0 1759
1830  
1831 1759 my $cc_components = [ $unmodified_char_class, $flags ];
1832  
1833 1759 $symbol = Marpa::R3::Internal::MetaAST::Symbol_List->new($symbol_name);
1834 1759 $cc_hash->{$symbol_name} = [ $cc_components, $symbol ];
1835  
1836 # description => "Character class: $char_class"
1837 1759 my $symbol_data = {
1838 dsl_form => $char_class,
1839 name_source => 'internal',
1840 };
1841  
1842 # description => "Character class: $char_class"
1843 1759 $parse->xsy_create( $symbol_name, $symbol_data );
1844 1759 $symbol_data = { xsy => $symbol_name };
1845 1759 $parse->symbol_names_set( $symbol_name, $subgrammar, $symbol_data );
1846 } ## end if ( not defined $symbol )
1847 1759 return $symbol;
1848 } ## end sub char_class_to_symbol
1849  
1850 6518 ▶sub Marpa::R3::Internal::MetaAST::Parse::symbol_names_set {
Subroutine symbol_names_set: called CC=3 SCAR=11.0
1851 6518 my ( $parse, $symbol, $subgrammar, $args ) = @_;
1852 6518 ▶ my $symbol_type = $subgrammar eq 'g1' ? 'g1' : 'l0';
Branch: 1 branch
BranchTrueFalseTotal
$subgrammar eq 'g1' ? : 1916 4602 6518
1853 6518 my $wsyid = $parse->{next_wsyid}++;
1854 6518 $parse->{symbols}->{$symbol_type}->{$symbol}->{wsyid} = $wsyid;
1855 6518 for my $arg_type (keys %{$args}) {
1856 6588 my $value = $args->{$arg_type};
1857 6588 $parse->{symbols}->{$symbol_type}->{$symbol}->{$arg_type} = $value;
1858 }
1859 6518 return $parse->{symbols}->{$symbol_type}->{$symbol};
1860 }
1861  
1862 # Return the priotized symbol name,
1863 # after ensuring everything is set up properly
1864 341 ▶sub Marpa::R3::Internal::MetaAST::Parse::prioritized_symbol {
Subroutine prioritized_symbol: called CC=3 SCAR=11.0
1865 341 my ( $parse, $base_symbol, $priority ) = @_;
1866  
1867 # character class symbol name always start with TWO left square brackets
1868 341 my $symbol_name = $base_symbol . '[' . $priority . ']';
1869 my $current_symbol_data =
1870 $parse->{symbols}
1871 ->{ $Marpa::R3::Internal::SUBGRAMMAR eq 'g1' ? 'g1' : 'l0' }
1872 341 ▶ ->{$symbol_name};
Branch: 1 branch
BranchTrueFalseTotal
$Marpa::R3::Internal::SUBGRAMMAR eq 'g1' ? : 341 0 341
1873 341 ▶ return $symbol_name if defined $current_symbol_data;
Branch: 1 branch
BranchTrueFalseTotal
if defined $current_symbol_data 271 70 341
1874  
1875 # description => "<$base_symbol> at priority $priority"
1876 70 my $symbol_data = {
1877 dsl_form => $base_symbol,
1878 name_source => 'lexical',
1879 };
1880 70 $parse->xsy_assign( $base_symbol, $symbol_data );
1881 70 $symbol_data = {
1882 xsy => $base_symbol,
1883 precedence => $priority,
1884 };
1885 70 $parse->symbol_names_set( $symbol_name, $Marpa::R3::Internal::SUBGRAMMAR,
1886 $symbol_data );
1887 70 return $symbol_name;
1888 } ## end sub Marpa::R3::Internal::MetaAST::Parse::prioritized_symbol
1889  
1890 197 ▶sub Marpa::R3::Internal::MetaAST::Parse::discard_symbol_assign {
Subroutine discard_symbol_assign: called CC=2 SCAR=6.9
1891 197 my ( $parse, $symbol_name ) = @_;
1892  
1893 my $current_symbol_data =
1894 197 $parse->{symbols}->{'l0'}->{$symbol_name};
1895 197 ▶ return $symbol_name if defined $current_symbol_data;
Branch: 1 branch
BranchTrueFalseTotal
if defined $current_symbol_data 53 144 197
1896  
1897 144 my $symbol_data = {
1898 dsl_form => $symbol_name,
1899 name_source => 'lexical',
1900 };
1901 144 $parse->xsy_assign( $symbol_name, $symbol_data );
1902 144 $symbol_data = { xsy => $symbol_name };
1903 144 return $parse->symbol_names_set( $symbol_name, 'l0', $symbol_data );
1904 } ## end sub Marpa::R3::Internal::MetaAST::Parse::prioritized_symbol
1905  
1906 4758 ▶sub Marpa::R3::Internal::MetaAST::Parse::xsy_create {
Subroutine xsy_create: called CC=2 SCAR=6.9
1907 4758 my ( $parse, $symbol_name, $args ) = @_;
1908 4758 my $xsy_data = $parse->{xsy}->{$symbol_name} = {};
1909  
1910 # Do I need to copy any more?
1911 # Can't I just use $args?
1912 4758 for my $datum (keys %{$args}) {
1913 9516 my $value = $args->{$datum};
1914 9516 $xsy_data->{$datum} = $value;
1915 }
1916 4758 return $xsy_data;
1917 }
1918  
1919 3895 ▶sub Marpa::R3::Internal::MetaAST::Parse::xsy_assign {
Subroutine xsy_assign: called CC=2 SCAR=6.9
1920 3895 my ( $parse, $symbol_name, $args ) = @_;
1921 3895 my $xsy_data = $parse->{xsy}->{$symbol_name};
1922 3895 ▶ return $xsy_data if $xsy_data;
Branch: 1 branch
BranchTrueFalseTotal
if $xsy_data 1464 2431 3895
1923 2431 return $parse->xsy_create( $symbol_name, $args );
1924 }
1925  
1926 # eXternal RuLe
1927 # At the moment, these are only for rules which can share
1928 # a LHS with a precedenced rule.
1929 1866 ▶sub Marpa::R3::Internal::MetaAST::xrl_create {
Subroutine xrl_create: called CC=5 SCAR=16.1
1930 1866 my ( $parse, $new_xrl ) = @_;
1931 1866 my $lhs = $new_xrl->{lhs};
1932 1866 my $start = $new_xrl->{start};
1933 1866 my $length = $new_xrl->{length};
1934 1866 ▶ $new_xrl->{precedence_count} //= 1;
Condition100%2/2
$new_xrl->{"precedence_count"} //= 1
l!l
1448418
MC/DC100%1/1
$new_xrl->{"precedence_count"} //= 1
$new_xrl->{"precedence_count"}
Truth table100%2/2
A
A= $new_xrl->{"precedence_count"}
Aresult
11
00
1935 1866 my $xrlid = sprintf '%s@%d+%d', $lhs, $start, $length;
1936 1866 my $xrls_by_lhs = $parse->{xrls_by_lhs}->{$lhs};
1937  
1938 1866 my $earlier_xrl = $xrls_by_lhs->[0];
1939 1866 ▶ if ( $earlier_xrl
Branch: 1 branch
BranchTrueFalseTotal
if ($earlier_xrl and $earlier_xrl->{"precedence_count"} > 1 || $new_xrl->{"precedence_count"} > 1) 3 1863 1866
Condition100%6/6
$earlier_xrl and $earlier_xrl->{"precedence_count"} > 1 || $new_xrl->{"precedence_count"} > 1
!ll&&!rl&&r
16851783
$earlier_xrl->{"precedence_count"} > 1 or $new_xrl->{"precedence_count"} > 1
l!l&&r!l&&!r
21178
MC/DC100%3/3
$earlier_xrl and $earlier_xrl->{"precedence_count"} > 1 || $new_xrl->{"precedence_count"} > 1
$earlier_xrl $earlier_xrl->{"precedence_count"} > 1 $new_xrl->{"precedence_count"} > 1
Truth table100%4/4
A and B or C
A= $earlier_xrlB= $earlier_xrl->{"precedence_count"} > 1C= $new_xrl->{"precedence_count"} > 1
ABCresult
0XX0
1000
11X1
1011
1940 and $earlier_xrl->{precedence_count} > 1
1941 || $new_xrl->{precedence_count} > 1 )
1942 {
1943  
1944 # If there was an earlier precedenced xrl
1945 # that needed to be unique for this LHS,
1946 # it was the only pre-existing xrl.
1947 # That's because we will never add another one, once it is on
1948 # list of XRLs by LHS.
1949 Marpa::R3::Internal::X->new(
1950 {
1951 desc => 'LHS not unique when required',
1952 xrl1 => $earlier_xrl,
1953 xrl2 => $new_xrl,
1954 3 ▶ to_string => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
1955 3 my $self = shift;
1956 3 my @string = ('Precedenced LHS not unique');
1957  
1958 3 my $pos1 = $self->{xrl1}->{start};
1959 3 my $len1 = $self->{xrl1}->{length};
1960 push @string,
1961 Marpa::R3::Internal::substr_as_2lines(
1962 (
1963 $self->{xrl1}->{precedence_count} > 1
1964 ? 'First precedenced rule'
1965 : 'First rule'
1966 ),
1967 $parse->{p_dsl},
1968 3 ▶ $pos1, $len1, 74
Branch: 1 branch
BranchTrueFalseTotal
$self->{'xrl1'}{'precedence_count'} > 1 ? : 2 1 3
1969 );
1970  
1971 3 my $pos2 = $self->{xrl2}->{start};
1972 3 my $len2 = $self->{xrl2}->{length};
1973 push @string,
1974 Marpa::R3::Internal::substr_as_2lines(
1975 (
1976 $self->{xrl2}->{precedence_count} > 1
1977 ? 'Second precedenced rule'
1978 : 'Second rule'
1979 ),
1980 $parse->{p_dsl},
1981 3 ▶ $pos2, $len2, 74
Branch: 1 branch
BranchTrueFalseTotal
$self->{'xrl2'}{'precedence_count'} > 1 ? : 2 1 3
1982 );
1983 3 push @string, q{};
1984  
1985 3 return join "\n", @string;
1986 }
1987 }
1988 3 )->throw();
1989 }
1990  
1991 1863 my $xrl_by_id = $parse->{xrl}->{$xrlid} = $new_xrl;
1992 1863 push @{ $parse->{xrls_by_lhs}->{$lhs} }, $new_xrl;
1993 1863 return $xrlid;
1994 }
1995  
1996 4258 ▶sub Marpa::R3::Internal::MetaAST::Parse::xpr_create {
Subroutine xpr_create: called CC=7 SCAR=19.5
1997 4258 my ( $parse, $args, $subgrammar ) = @_;
1998  
1999 # The eXternal ALTernative is the argument hash,
2000 # slightly adjusted.
2001 4258 ▶ $subgrammar //= 'g1';
Condition50%1/2
$subgrammar //= "g1"
l!l
42580
MC/DC0%0/1
$subgrammar //= "g1"
$subgrammar
Truth table50%1/2
A
A= $subgrammar
Aresult
11
00
2002 4258 ▶ $args->{subgrammar} //= $subgrammar;
Condition33%1/3
$args->{"subgrammar"} //= $subgrammar
l!l&&r!l&&!r
042580
MC/DC0%0/2
$args->{"subgrammar"} //= $subgrammar
$args->{"subgrammar"} $subgrammar
Truth table33%1/3
A //= B
A= $args->{"subgrammar"}B= $subgrammar
ABresult
1X1
011
000
2003 4258 ▶ $args->{subkey} //= 0;
Condition100%2/2
$args->{"subkey"} //= 0
l!l
21672091
MC/DC100%1/1
$args->{"subkey"} //= 0
$args->{"subkey"}
Truth table100%2/2
A
A= $args->{"subkey"}
Aresult
11
00
2004 4258 my $rule_id = join q{,}, $subgrammar, $args->{lhs}, @{$args->{rhs}};
2005 4258 my $hash_by_xprid = $parse->{xpr}->{$subgrammar};
2006 4258 ▶ if ( exists $hash_by_xprid->{$rule_id} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $hash_by_xprid->{$rule_id}) 2 4256 4258
2007 2 my $other_xpr = $hash_by_xprid->{$rule_id};
2008 2 my $pos1 = $other_xpr->{start};
2009 2 my $len1 = $other_xpr->{length};
2010 2 my $pos2 = $args->{start};
2011 2 my $len2 = $args->{length};
2012 my @string = (
2013 "Duplicate rules:",
2014 Marpa::R3::Internal::substr_as_2lines(
2015 'First rule', $parse->{p_dsl}, $pos1, $len1, 74
2016 ),
2017 Marpa::R3::Internal::substr_as_2lines(
2018 2 'Second rule', $parse->{p_dsl}, $pos2, $len2, 74
2019 )
2020 );
2021 2 Marpa::R3::exception( join "\n", @string, q{} );
2022 }
2023 4256 $hash_by_xprid->{$rule_id} = $args;
2024  
2025 # Now create the initial working rule
2026 4256 my %wrl = (
2027 xprid => $rule_id,
2028 subgrammar => $subgrammar,
2029 );
2030 # Shallow copy
2031 4256 for my $field (
2032 qw(lhs action priority rank
2033 null_ranking min separator proper )
2034 )
2035 {
2036 34048 ▶ $wrl{$field} = $args->{$field} if defined $args->{$field};
Branch: 1 branch
BranchTrueFalseTotal
if defined $args->{$field} 5797 28251 34048
2037 }
2038 # 'rhs' needs special treatment --
2039 # a deeper code and creation of the xpr_dot field
2040 {
2041 4256 my $rhs = $args->{rhs};
2042 4256 my $xpr_datum = $rhs;
2043 4256 my @array = @{$rhs};
2044 4256 $wrl{rhs} = \@array;
2045 4256 $wrl{xpr_dot} = [0 .. (scalar @array) ];
2046 4256 $wrl{xpr_top} = 1;
2047 }
2048  
2049 # Return the initial working rule
2050 4256 return \%wrl;
2051  
2052 }
2053  
2054 # Return the prioritized symbol name,
2055 # after ensuring everything is set up properly
2056 296 ▶sub Marpa::R3::Internal::MetaAST::Parse::internal_lexeme {
Subroutine internal_lexeme: called CC=2 SCAR=6.9
2057 296 my ( $parse, $dsl_form, @grammars ) = @_;
2058  
2059 # character class symbol name always start with TWO left square brackets
2060 296 my $lexical_lhs_index = $parse->{lexical_lhs_index}++;
2061 296 my $lexical_symbol = "[Lex-$lexical_lhs_index]";
2062  
2063 # description => qq{Internal lexical symbol for "$dsl_form"}
2064 296 my $symbol_data = {
2065 dsl_form => $dsl_form,
2066 name_source => 'internal'
2067 };
2068 296 $parse->xsy_assign( $lexical_symbol, $symbol_data );
2069 296 $symbol_data = { xsy => $lexical_symbol };
2070 296 $parse->symbol_names_set( $lexical_symbol, $_, $symbol_data ) for qw(g1 l0);
2071 296 return $lexical_symbol;
2072 } ## end sub Marpa::R3::Internal::MetaAST::Parse::internal_lexeme
2073  
2074 455 ▶sub name {
Subroutine name: called CC=2 SCAR=7.2
2075 455 my ($self) = @_;
2076 455 my $names = $self->{names};
2077 Marpa::R3::exception( 'list->name() on symbol list of length ',
2078 0 scalar @{$names} )
2079 455 ▶ if scalar @{$names} != 1;
Branch: 1 branch
BranchTrueFalseTotal
if scalar @{$names;} != 1 0 455 455
2080 455 return $self->{names}->[0];
2081 } ## end sub name
2082 9657 ▶sub names { return shift->{names} }
Subroutine names: called CC=1 SCAR=0.0
2083 9361 ▶sub mask { return shift->{mask} }
Subroutine mask: called CC=1 SCAR=0.0
2084  
2085 77 ▶sub mask_set {
Subroutine mask_set: called CC=1 SCAR=0.0
2086 77 my ( $self, $mask ) = @_;
2087 77 return $self->{mask} = [ map {$mask} @{ $self->{mask} } ];
2088 }
2089  
2090 104 1;
2091  
2092 # vim: expandtab shiftwidth=4:
« R3/Glade.pm ↑ Summary R3/X.pm »