blib/lib/Lang/HL.pm

filter: Statementstmt 1.8% 16 / 849 Branchbran 0.0% 0 / 62 Conditioncond 0.0% 0 / 453 MC/DCmcdc 0.0% 0 / 175 Subroutinesub 2.2% 4 / 179 Podpod 0.0% 0 / 2 totaltotal 1.1% 20 / 1720 CC 213 SCAR 41.7
CC
213
Cov
1%
X
380.0
X
272.0
X
182.0
CRAP 64.5
↑ Summary
1 package Lang::HL;
2  
3 1 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 1 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 1 ▶use utf8;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 1 ▶use Regexp::Grammars;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 1 our $VERSION = '5.052';
9  
10 0 ▶sub new {
Subroutine new: not called CC=1 SCAR=6.9
Pod undocumented
11 0 my ($class) = @_;
12 0 return bless {}, $class;
13 }
14  
15 1 my $groupTable = {};
16  
17 0 ▶sub PT::Lang::X {
Subroutine X: not called CC=2 SCAR=17.9
18 0 my ($class) = @_;
19  
20 0 my $code = 'use strict;
21 use warnings;
22 use utf8;
23  
24 package Lang::HL::Export;
25  
26 use strict;
27 no warnings;
28 use utf8;
29 use feature qw(signatures);
30 no warnings "experimental::signatures";
31 no warnings "experimental::smartmatch";
32 use Hash::Merge;
33  
34 require Exporter;
35  
36 our @ISA = qw(Exporter);
37 our @EXPORT = qw(
38 arrayElement
39 arrayLength
40 arrayMerge
41 arraySort
42 arrayPop
43 arrayPush
44 arrayShift
45 arrayUnshift
46 arraySort
47 arrayJoin
48 arrayReverse
49 arrayDelete
50 hashKeys
51 hashElement
52 hashMerge
53 hashDelete
54 stringConcat
55 readFile
56 writeFile
57 not
58 );
59  
60 sub not($boolOperand) {
61 my $not = ! $boolOperand;
62 return $not;
63 }
64  
65 sub arrayElement($array, $element) {
66 if( $element ~~ @{$array} ) {
67 return 1;
68 } else {
69 return 0;
70 }
71 }
72  
73 sub arrayDelete($array, $element) {
74 delete($array->[$element]);
75 }
76  
77 sub hashDelete($hash, $element) {
78 delete($hash->{$element});
79 }
80  
81 sub arrayReverse($array) {
82 my @reversedArray = reverse(@{$array});
83 return \@reversedArray;
84 }
85  
86 sub arrayJoin($separator, $array) {
87 my @array = @{$array};
88 return join($separator, $array);
89 }
90  
91 sub arraySort($array) {
92 my @array = @{$array};
93 my @sortedArray = sort(@array);
94 return \@sortedArray;
95 }
96  
97 sub arrayUnshift($array, $element) {
98 unshift(@{$array}, $element);
99 }
100  
101 sub arrayShift($array) {
102 return shift(@{$array});
103 }
104  
105 sub arrayPush($array, $element) {
106 push(@{$array}, $element);
107 }
108  
109 sub arrayPop($array) {
110 return pop(@{$array});
111 }
112  
113 sub stringConcat($textOne, $textTwo) {
114 return $textOne . $textTwo;
115 }
116  
117 sub arrayLength($array) {
118 my @newArray = @{$array};
119 return $#newArray;
120 }
121  
122 sub arrayMerge($arrayOne, $arrayTwo) {
123 my @newArray = ( @{$arrayOne}, @{$arrayTwo} );
124 return \@newArray;
125 }
126  
127 sub hashElement($hash, $element) {
128 my %hashMap = %{$hash};
129 if( exists $hashMap{$element} ) {
130 return 1;
131 } else {
132 return 0;
133 }
134 }
135  
136 sub hashKeys($hash) {
137 my @keys = keys(%{$hash});
138 return \@keys;
139 }
140  
141 sub hashMerge($hashOne, $hashTwo) {
142 my $mergedHash = merge($hashOne, $hashTwo);
143 return $mergedHash;
144 }
145  
146 sub readFile($fileName) {
147 my $fileContent;
148 open(my $fh, "<:encoding(UTF-8)", $fileName) or die "Cannot open the $fileName file";
149 {
150 local $/;
151 $fileContent = <$fh>;
152 }
153 close($fh);
154 return $fileContent;
155 }
156  
157 sub writeFile($fileName, $fileContent) {
158 open(my $fh, ">:encoding(UTF-8)", $fileName) or die "Cannot open the $fileName file";
159 print $fh $fileContent;
160 close($fh);
161 }
162  
163 1;';
164  
165 0 for my $element ( @{ $class->{Class}} ) {
166 0 $code .= $element->X();
167 }
168  
169 0 $code .= 'my $object = Main->new(); $object->main();';
170 0 return $code;
171 }
172  
173 0 ▶sub PT::Class::X {
Subroutine X: not called CC=1 SCAR=6.9
174 0 my ($class) = @_;
175  
176 0 my $className = $class->{ClassName}->X();
177 0 my $classBlock = $class->{ClassBlock}->X($className);
178  
179 0 my $classCode = '
180 package ' . $className . ';
181 use strict;
182 use warnings;
183 use utf8;
184 use Lang::HL::Export;
185 use feature qw(signatures);
186 no warnings "experimental::signatures";
187 use Data::Printer;
188 use Try::Tiny;
189 ';
190  
191 0 $classCode .= $classBlock . "\n1;";
192 0 return $classCode;
193 }
194  
195 0 ▶sub PT::ClassName::X {
Subroutine X: not called CC=1 SCAR=6.9
196 0 my ($class) = @_;
197 0 my $className = $class->{''};
198 0 return $className;
199 }
200  
201 0 ▶sub PT::ClassBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
202 0 my ($class, $className) = @_;
203  
204 0 my $classBlock = '
205 sub new($class) {
206 my $hashRef = { "' . $className . '" => {} };
207 return bless $hashRef, $class;
208 }
209 ';
210  
211 0 my $errorLBrace = $class->{ErrorLBrace}->X($className);
212 0 my $classGroups = $class->{ClassGroups}->X($className);
213 0 my $errorRBrace = $class->{ErrorRBrace}->X($className);
214  
215 0 $classBlock .= $classGroups;
216 0 return $classBlock;
217 }
218  
219 0 ▶sub PT::ErrorLBrace::X {
Subroutine X: not called CC=2 SCAR=17.9
220 0 my ($class, $className) = @_;
221  
222 return ( $class->{LBrace}
223 0 ▶ || $class->{LBraceError} )->X($className);
Condition0%0/3
$class->{'LBrace'} || $class->{'LBraceError'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'LBrace'} || $class->{'LBraceError'}
$class->{'LBrace'} $class->{'LBraceError'}
Truth table0%0/3
A || B
A= $class->{'LBrace'}B= $class->{'LBraceError'}
ABresult
1X1
011
000
224 }
225  
226 0 ▶sub PT::ErrorRBrace::X {
Subroutine X: not called CC=2 SCAR=17.9
227 0 my ($class, $className) = @_;
228  
229 return ( $class->{RBrace}
230 0 ▶ || $class->{RBraceError} )->X($className);
Condition0%0/3
$class->{'RBrace'} || $class->{'RBraceError'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'RBrace'} || $class->{'RBraceError'}
$class->{'RBrace'} $class->{'RBraceError'}
Truth table0%0/3
A || B
A= $class->{'RBrace'}B= $class->{'RBraceError'}
ABresult
1X1
011
000
231 }
232  
233 0 ▶sub PT::ClassGroups::X {
Subroutine X: not called CC=2 SCAR=17.9
234 0 my ($class, $className) = @_;
235  
236 0 my @classGroups;
237 0 for my $element ( @{$class->{Group}} ) {
238 0 push @classGroups, $element->X($className);
239 }
240  
241 0 my $classGroups = join("", @classGroups);
242 0 return $classGroups;
243 }
244  
245 0 ▶sub PT::Group::X {
Subroutine X: not called CC=8 SCAR=42.8
246 0 my ($class, $className) = @_;
247  
248 return ( $class->{Comment}
249 || $class->{Parent}
250 || $class->{Packages}
251 || $class->{ImplementFunction}
252 || $class->{EmbedBlock}
253 || $class->{Function}
254 || $class->{GroupDeclaration}
255 0 ▶ || $class->{NonSyntaxClass} )->X($className);
Condition0%0/21
$class->{'Comment'} || $class->{'Parent'} || $class->{'Packages'} || $class->{'ImplementFunction'} || $class->{'EmbedBlock'} || $class->{'Function'} || $class->{'GroupDeclaration'} || $class->{'NonSyntaxClass'}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"} or $class->{"Packages"} or $class->{"ImplementFunction"} or $class->{"EmbedBlock"} or $class->{"Function"} or $class->{"GroupDeclaration"}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"} or $class->{"Packages"} or $class->{"ImplementFunction"} or $class->{"EmbedBlock"} or $class->{"Function"}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"} or $class->{"Packages"} or $class->{"ImplementFunction"} or $class->{"EmbedBlock"}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"} or $class->{"Packages"} or $class->{"ImplementFunction"}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"} or $class->{"Packages"}
l!l&&r!l&&!r
000
$class->{"Comment"} or $class->{"Parent"}
l!l&&r!l&&!r
000
MC/DC0%0/8
$class->{'Comment'} || $class->{'Parent'} || $class->{'Packages'} || $class->{'ImplementFunction'} || $class->{'EmbedBlock'} || $class->{'Function'} || $class->{'GroupDeclaration'} || $class->{'NonSyntaxClass'}
$class->{"Comment"} $class->{"Parent"} $class->{"Packages"} $class->{"ImplementFunction"} $class->{"EmbedBlock"} $class->{"Function"} $class->{"GroupDeclaration"} $class->{'NonSyntaxClass'}
Truth table0%0/9
A or B or C or D or E or F or G || H
A= $class->{"Comment"}B= $class->{"Parent"}C= $class->{"Packages"}D= $class->{"ImplementFunction"}E= $class->{"EmbedBlock"}F= $class->{"Function"}G= $class->{"GroupDeclaration"}H= $class->{'NonSyntaxClass'}
ABCDEFGHresult
1XXXXXXX1
01XXXXXX1
001XXXXX1
0001XXXX1
00001XXX1
000001XX1
0000001X1
000000011
000000000
256 }
257  
258 0 ▶sub PT::ImplementFunction::X {
Subroutine X: not called CC=2 SCAR=17.9
259 0 my ($class, $className) = @_;
260  
261 0 my $functionName = $class->{FunctionName}->X($className);
262 0 my $functionParamList = $class->{FunctionParamList}->X($className);
263  
264 0 my $multiLineComment = "";
265 0 ▶ if(exists $class->{MultiLineComment}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"MultiLineComment"}) 0 0 0
266 0 my $multiLineComment = $class->{MultiLineComment}->X($className);
267 }
268  
269 0 my $dieMessage = "function " . $functionName . " in class " . $className . " is not defined \n";
270 0 my $implementFunction = "sub " . $functionName . $functionParamList . "{\n" . $multiLineComment . "\n die(" . $dieMessage . ");}\n";
271  
272 0 return $implementFunction;
273 }
274  
275 0 ▶sub PT::MultiLineComment::X {
Subroutine X: not called CC=1 SCAR=6.9
276 0 my ($class, $className) = @_;
277  
278 0 my $mlComment = $class->{MLComment}->X($className);
279 0 return $mlComment;
280 }
281  
282 0 ▶sub PT::MLComment::X {
Subroutine X: not called CC=1 SCAR=6.9
283 0 my ($class, $className) = @_;
284 0 my $mlComment = $class->{''};
285 0 return $mlComment;
286 }
287  
288 0 ▶sub PT::NonSyntaxClass::X {
Subroutine X: not called CC=1 SCAR=6.9
289 0 my ($class, $className) = @_;
290 0 my $nonSyntax = $class->{''};
291  
292 0 my @nonSyntax = split(" ", $nonSyntax);
293 0 $nonSyntax = $nonSyntax[0];
294  
295 0 print "SyntaxError", "\n";
296 0 print "===========", "\n";
297 0 print "ClassName: ", $className, "\n";
298 0 die "Error: $nonSyntax \n";
299 }
300  
301 0 ▶sub PT::Packages::X {
Subroutine X: not called CC=1 SCAR=6.9
302 0 my ($class, $className) = @_;
303  
304 0 my @packageList = ($class->{PackageList})->X($className);
305 0 my $packages = join("\n", @packageList);
306 0 return $packages;
307 }
308  
309 0 ▶sub PT::PackageList::X {
Subroutine X: not called CC=2 SCAR=17.9
310 0 my ($class, $className) = @_;
311  
312 0 my @packageList;
313 0 for my $element ( @{$class->{Package}} ) {
314 0 push @packageList, $element->X($className);
315 }
316  
317 0 return @packageList;
318 }
319  
320 0 ▶sub PT::Package::X {
Subroutine X: not called CC=2 SCAR=17.9
321 0 my ($class, $className) = @_;
322  
323 return ( $class->{PackageWithConstructor}
324 0 ▶ || $class->{PackageWithoutConstructor} )->X($className);
Condition0%0/3
$class->{'PackageWithConstructor'} || $class->{'PackageWithoutConstructor'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'PackageWithConstructor'} || $class->{'PackageWithoutConstructor'}
$class->{'PackageWithConstructor'} $class->{'PackageWithoutConstructor'}
Truth table0%0/3
A || B
A= $class->{'PackageWithConstructor'}B= $class->{'PackageWithoutConstructor'}
ABresult
1X1
011
000
325 }
326  
327 0 ▶sub PT::PackageWithConstructor::X {
Subroutine X: not called CC=3 SCAR=24.8
328 0 my ($class, $className) = @_;
329  
330 0 my $object = $class->{Object}->X($className);
331 0 my $packageName = $class->{PackageName}->X($className);
332 0 my $constructor = $class->{Constructor}->X($className);
333  
334 0 ▶ if(exists $class->{ObjectParameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"ObjectParameters"}) 0 0 0
335 0 my $objectParameters = $class->{ObjectParameters}->X($className);
336 0 my $parameters;
337  
338 0 ▶ if(ref($objectParameters)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $objectParameters) { } 0 0 0
339 0 $parameters = join(",", @{$objectParameters});
340 } else {
341 0 $parameters = $objectParameters;
342 }
343  
344 0 my $packageWithConstructor = "use " . $packageName . ";\n"
345 . "my \$" . $object . " = " . $packageName . "->"
346 . $constructor . "(" . $parameters . ");\n";
347 0 return $packageWithConstructor;
348 }
349  
350 0 my $packageWithConstructor = "use " . $packageName . ";\n"
351 . "my \$" . $object . " = " . $packageName
352 . "->" . $constructor . "();\n";
353 0 return $packageWithConstructor;
354 }
355  
356 0 ▶sub PT::ObjectParameters::X {
Subroutine X: not called CC=2 SCAR=17.9
357 0 my ($class, $className) = @_;
358  
359 return ( $class->{PackageParams}
360 0 ▶ || $class->{Parameters} )->X($className);
Condition0%0/3
$class->{'PackageParams'} || $class->{'Parameters'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'PackageParams'} || $class->{'Parameters'}
$class->{'PackageParams'} $class->{'Parameters'}
Truth table0%0/3
A || B
A= $class->{'PackageParams'}B= $class->{'Parameters'}
ABresult
1X1
011
000
361 }
362  
363 0 ▶sub PT::PackageParams::X {
Subroutine X: not called CC=2 SCAR=17.9
364 0 my ($class, $className) = @_;
365 0 my @keyValuePairs;
366  
367 0 my $keyValuePairs = "";
368 0 for my $element ( @{ $class->{KeyValue}} ) {
369 0 @keyValuePairs = ();
370 0 push @keyValuePairs, $element->X($className);
371 0 $keyValuePairs .= $keyValuePairs[0] . " => " . $keyValuePairs[1] . ", ";
372 }
373  
374 0 return $keyValuePairs;
375 }
376  
377 0 ▶sub PT::PackageName::X {
Subroutine X: not called CC=2 SCAR=17.9
378 0 my ($class, $className) = @_;
379  
380 0 my @packageDir;
381 0 for my $element ( @{ $class->{PackageDir}} ) {
382 0 push @packageDir, $element->X($className);
383 }
384  
385 0 my $packageName = join("::", @packageDir);
386 0 return $packageName;
387 }
388  
389 0 ▶sub PT::PackageWithoutConstructor::X {
Subroutine X: not called CC=2 SCAR=17.9
390 0 my ($class, $className) = @_;
391 0 my $packageName = $class->{PackageName}->X($className);
392  
393 0 ▶ if(exists $class->{QW}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"QW"}) 0 0 0
394 0 my $qw = $class->{QW}->X($className);
395  
396 0 my $packageWithoutConstructor = "use " . $packageName . $qw . ";\n";
397 0 return $packageWithoutConstructor;
398 }
399  
400 0 my $packageWithoutConstructor = "use " . $packageName . ";\n";
401 0 return $packageWithoutConstructor;
402 }
403  
404 0 ▶sub PT::QW::X {
Subroutine X: not called CC=1 SCAR=6.9
405 0 my ($class, $className) = @_;
406  
407 0 my @functionList = $class->{FunctionList}->X($className);
408 0 my $qw = " qw(";
409 0 my $funcitonList = join(" ", @functionList);
410 0 $qw .= $funcitonList . ")";
411 }
412  
413 0 ▶sub PT::FunctionList::X {
Subroutine X: not called CC=2 SCAR=17.9
414 0 my ($class, $className) = @_;
415  
416 0 my @functionList;
417 0 for my $element ( @{ $class->{FunctionName}} ) {
418 0 push @functionList, $element->X($className);
419 }
420  
421 0 return @functionList;
422 }
423  
424 0 ▶sub PT::Constructor::X {
Subroutine X: not called CC=1 SCAR=6.9
425 0 my ($class, $className) = @_;
426  
427 0 my $constructor = $class->{''};
428 0 return $constructor;
429 }
430  
431 0 ▶sub PT::Object::X {
Subroutine X: not called CC=1 SCAR=6.9
432 0 my ($class, $className) = @_;
433  
434 0 my $object = $class->{''};
435 0 return $object;
436 }
437  
438 0 ▶sub PT::PackageDir::X {
Subroutine X: not called CC=1 SCAR=6.9
439 0 my ($class, $className) = @_;
440  
441 0 my $packageDir = $class->{''};
442 0 return $packageDir;
443 }
444  
445 0 ▶sub PT::Parent::X {
Subroutine X: not called CC=1 SCAR=6.9
446 0 my ($class, $className) = @_;
447 0 my $parent = 'our @ISA = qw(';
448  
449 0 my $classNames = $class->{ClassNames}->X($className);
450 0 $parent .= $classNames . ");\n";
451 }
452  
453 0 ▶sub PT::ClassNames::X {
Subroutine X: not called CC=2 SCAR=17.9
454 0 my ($class, $className) = @_;
455  
456 0 my @classNames;
457 0 for my $element ( @{$class->{ClassName}} ) {
458 0 push @classNames, $element->X($className);
459 }
460  
461 0 my $classNames = join(" ", @classNames);
462 0 return $classNames;
463 }
464  
465 0 ▶sub PT::Comment::X {
Subroutine X: not called CC=1 SCAR=6.9
466 0 my ($class, $className) = @_;
467 0 my $comment = $class->{LineComment}->X($className);
468 0 $comment = "\n" . "# " . $comment . "\n";
469 0 return $comment;
470 }
471  
472 0 ▶sub PT::LineComment::X {
Subroutine X: not called CC=1 SCAR=6.9
473 0 my ($class, $className) = @_;
474 0 return $class->{''};
475 }
476  
477 0 ▶sub PT::Function::X {
Subroutine X: not called CC=1 SCAR=6.9
478 0 my ($class, $className) = @_;
479  
480 0 my $functionName = $class->{FunctionName}->X($className);
481 0 my $functionParamList = $class->{FunctionParamList}->X($className);
482 0 my $codeBlock = $class->{CodeBlock}->X($className, $functionName);
483  
484 0 my $function = "\n sub " . $functionName . $functionParamList . $codeBlock;
485 0 return $function;
486 }
487  
488 0 ▶sub PT::FunctionName::X {
Subroutine X: not called CC=1 SCAR=6.9
489 0 my ($class, $className) = @_;
490  
491 0 my $functionName = $class->{''};
492 0 return $functionName;
493 }
494  
495 0 ▶sub PT::FunctionParamList::X {
Subroutine X: not called CC=6 SCAR=37.4
496 0 my ($class, $className) = @_;
497  
498 my @params = ( $class->{EmptyParamList}
499 0 ▶ || $class->{FunctionParams} )->X($className);
Condition0%0/3
$class->{'EmptyParamList'} || $class->{'FunctionParams'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'EmptyParamList'} || $class->{'FunctionParams'}
$class->{'EmptyParamList'} $class->{'FunctionParams'}
Truth table0%0/3
A || B
A= $class->{'EmptyParamList'}B= $class->{'FunctionParams'}
ABresult
1X1
011
000
500  
501 0 my $functionParamList;
502 0 $functionParamList = '( $class, ';
503  
504 0 ▶ if($#params >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($#params >= 0) { } 0 0 0
505 0 foreach my $param (@params) {
506 0 ▶ if( $param eq "" ) {} else {
Branch: 1 branch
BranchTrueFalseTotal
if ($param eq '') { } 0 0 0
507 0 $functionParamList .= "\$" . $param . ",";
508 }
509 }
510 0 ▶ if( substr($functionParamList, -1) eq "," ) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($functionParamList, -1) eq ",") 0 0 0
511 0 chop($functionParamList);
512 }
513 }
514 else {
515 0 chop($functionParamList);
516 }
517 0 $functionParamList .= ")";
518  
519 0 return $functionParamList;
520 }
521  
522 0 ▶sub PT::CodeBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
523 0 my ($class, $className, $functionName) = @_;
524 0 my $blocks = $class->{Blocks}->X($className, $functionName);
525 0 my $codeBlock = "{\n" . $blocks . "\n}";
526 0 return $codeBlock;
527 }
528  
529 0 ▶sub PT::EmptyParamList::X {
Subroutine X: not called CC=1 SCAR=6.9
530 0 my ($class, $className) = @_;
531 0 return $class->{''};
532 }
533  
534 0 ▶sub PT::FunctionParams::X {
Subroutine X: not called CC=2 SCAR=17.9
535 0 my ($class, $className) = @_;
536 0 my @functionParams;
537  
538 0 for my $element ( @{ $class->{Arg}} ) {
539 0 push @functionParams, $element->X($className);
540 }
541  
542 0 return @functionParams;
543 }
544  
545 0 ▶sub PT::Arg::X {
Subroutine X: not called CC=1 SCAR=6.9
546 0 my ($class, $className) = @_;
547 0 return $class->{''};
548 }
549  
550 0 ▶sub PT::Blocks::X {
Subroutine X: not called CC=2 SCAR=17.9
551 0 my ($class, $className, $functionName) = @_;
552 0 my @blocks;
553  
554 0 for my $element ( @{$class->{Block}} ) {
555 0 push @blocks, $element->X($className, $functionName);
556 }
557  
558 0 my $blocks = join("\n", @blocks);
559 0 return $blocks;
560 }
561  
562 0 ▶sub PT::Block::X {
Subroutine X: not called CC=13 SCAR=52.0
563 0 my ($class, $className, $functionName) = @_;
564  
565 my $block = ( $class->{IfElse}
566 || $class->{While}
567 || $class->{ForEach}
568 || $class->{ArrayEach}
569 || $class->{HashEach}
570 || $class->{For}
571 || $class->{RegexMatch}
572 || $class->{TryCatch}
573 || $class->{EmbedBlock}
574 || $class->{Comment}
575 || $class->{Statement}
576 || $class->{Packages}
577 0 ▶ || $class->{NonSyntaxFunction} )->X($className, $functionName);
Condition0%0/36
$class->{'IfElse'} || $class->{'While'} || $class->{'ForEach'} || $class->{'ArrayEach'} || $class->{'HashEach'} || $class->{'For'} || $class->{'RegexMatch'} || $class->{'TryCatch'} || $class->{'EmbedBlock'} || $class->{'Comment'} || $class->{'Statement'} || $class->{'Packages'} || $class->{'NonSyntaxFunction'}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"} or $class->{"TryCatch"} or $class->{"EmbedBlock"} or $class->{"Comment"} or $class->{"Statement"} or $class->{"Packages"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"} or $class->{"TryCatch"} or $class->{"EmbedBlock"} or $class->{"Comment"} or $class->{"Statement"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"} or $class->{"TryCatch"} or $class->{"EmbedBlock"} or $class->{"Comment"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"} or $class->{"TryCatch"} or $class->{"EmbedBlock"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"} or $class->{"TryCatch"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"} or $class->{"RegexMatch"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"} or $class->{"For"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"} or $class->{"HashEach"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"} or $class->{"ArrayEach"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"} or $class->{"ForEach"}
l!l&&r!l&&!r
000
$class->{"IfElse"} or $class->{"While"}
l!l&&r!l&&!r
000
MC/DC0%0/13
$class->{'IfElse'} || $class->{'While'} || $class->{'ForEach'} || $class->{'ArrayEach'} || $class->{'HashEach'} || $class->{'For'} || $class->{'RegexMatch'} || $class->{'TryCatch'} || $class->{'EmbedBlock'} || $class->{'Comment'} || $class->{'Statement'} || $class->{'Packages'} || $class->{'NonSyntaxFunction'}
$class->{"IfElse"} $class->{"While"} $class->{"ForEach"} $class->{"ArrayEach"} $class->{"HashEach"} $class->{"For"} $class->{"RegexMatch"} $class->{"TryCatch"} $class->{"EmbedBlock"} $class->{"Comment"} $class->{"Statement"} $class->{"Packages"} $class->{'NonSyntaxFunction'}
Truth table0%0/14
A or B or C or D or E or F or G or H or I or J or K or L || M
A= $class->{"IfElse"}B= $class->{"While"}C= $class->{"ForEach"}D= $class->{"ArrayEach"}E= $class->{"HashEach"}F= $class->{"For"}G= $class->{"RegexMatch"}H= $class->{"TryCatch"}I= $class->{"EmbedBlock"}J= $class->{"Comment"}K= $class->{"Statement"}L= $class->{"Packages"}M= $class->{'NonSyntaxFunction'}
ABCDEFGHIJKLMresult
1XXXXXXXXXXXX1
01XXXXXXXXXXX1
001XXXXXXXXXX1
0001XXXXXXXXX1
00001XXXXXXXX1
000001XXXXXXX1
0000001XXXXXX1
00000001XXXXX1
000000001XXXX1
0000000001XXX1
00000000001XX1
000000000001X1
00000000000011
00000000000000
578 0 return $block;
579 }
580  
581 0 ▶sub PT::RegexMatch::X {
Subroutine X: not called CC=1 SCAR=6.9
582 0 my ($class, $className) = @_;
583  
584 0 my $pattern = $class->{Pattern}->X($className);
585 0 my $matchString = $class->{MatchString}->X($className);
586 0 my $codeBlock = $class->{CodeBlock}->X($className);
587  
588 0 my $regexMatch = "if(" . $matchString . " =~ " . $pattern . ")" . $codeBlock;
589 0 return $regexMatch;
590 }
591  
592 0 ▶sub PT::Pattern::X {
Subroutine X: not called CC=1 SCAR=6.9
593 0 my ($class, $className) = @_;
594  
595 0 my $pattern = $class->{VariableName}->X($className);
596 0 return $pattern;
597 }
598  
599 0 ▶sub PT::MatchString::X {
Subroutine X: not called CC=1 SCAR=6.9
600 0 my ($class, $className) = @_;
601  
602 0 my $matchString = $class->{VariableName}->X($className);
603 0 return $matchString;
604 }
605  
606 0 ▶sub PT::TryCatch::X {
Subroutine X: not called CC=2 SCAR=17.9
607 0 my ($class, $className) = @_;
608  
609 0 my $codeBlock = $class->{CodeBlock}->X($className);
610 0 ▶ if(exists $class->{CatchBlock}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{'CatchBlock'}) { } 0 0 0
611 0 my $catchBlock = $class->{CatchBlock}->X($className);
612 0 my $tryCatch = "try " . $codeBlock . $catchBlock . ";";
613 0 return $tryCatch;
614 } else {
615 0 my $tryCatch = "try {\n " . $codeBlock . "\n}";
616 0 return $tryCatch;
617 }
618 }
619  
620 0 ▶sub PT::CatchBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
621 0 my ($class, $className) = @_;
622  
623 0 my $codeBlock = $class->{CodeBlock}->X($className);
624 0 my @codeBlock = split(" ", $codeBlock);
625 0 shift(@codeBlock);
626 0 my $catchBlock = " catch {\n my \$error = \$_;\n " . join(" ", @codeBlock);
627  
628 0 return $catchBlock;
629 }
630  
631 0 ▶sub PT::NonSyntaxFunction::X {
Subroutine X: not called CC=2 SCAR=17.9
632 0 my ($class, $className, $functionName) = @_;
633 0 my $nonSyntax = $class->{''};
634  
635 0 my @nonSyntax = split(" ", $nonSyntax);
636 0 $nonSyntax = $nonSyntax[0];
637  
638 0 print "SyntaxError", "\n";
639 0 print "===========", "\n";
640 0 print "ClassName: ", $className, "\n";
641  
642 0 ▶ if(defined $functionName) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $functionName) 0 0 0
643 0 print "FunctionName: ", $functionName, "\n";
644 }
645  
646 0 die "Error: $nonSyntax \n";
647 }
648  
649 0 ▶sub PT::EmbedBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
650 0 my ($class, $className) = @_;
651  
652 0 my $embedBlock = $class->{EmbedCodeBlock}->X($className);
653 0 return $embedBlock;
654 }
655  
656 0 ▶sub PT::EmbedCodeBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
657 0 my ($class, $className) = @_;
658  
659 0 my $embedCode = $class->{EmbeddedCode}->X($className);
660 0 return $embedCode;
661 }
662  
663 0 ▶sub PT::EmbeddedCode::X {
Subroutine X: not called CC=1 SCAR=6.9
664 0 my ($class, $className) = @_;
665  
666 0 my $embedCode = $class->{''};
667 0 return $embedCode;
668 }
669  
670 0 ▶sub PT::While::X {
Subroutine X: not called CC=1 SCAR=6.9
671 0 my ($class, $className) = @_;
672  
673 0 my $boolExpression = $class->{BoolExpression}->X($className);
674 0 my $codeBlock = $class->{CodeBlock}->X($className);
675  
676 0 my $while = "\n while ( " . $boolExpression . " ) " . $codeBlock;
677 0 return $while;
678 }
679  
680 0 ▶sub PT::ForEach::X {
Subroutine X: not called CC=1 SCAR=6.9
681 0 my ($class, $className) = @_;
682  
683 0 my $forEachVariableName = $class->{VariableName}->X($className);
684 0 my @forRange = $class->{ForRange}->X($className);
685 0 my $codeBlock = $class->{CodeBlock}->X($className);
686  
687 0 my $forEach = "\n foreach my " . $forEachVariableName . " ( " . $forRange[0]
688 . " ... " . $forRange[1] . " ) " . $codeBlock;
689  
690 0 return $forEach;
691 }
692  
693 0 ▶sub PT::ForEachVariableName::X {
Subroutine X: not called CC=1 SCAR=6.9
694 0 my ($class, $className) = @_;
695  
696 0 my $variableName = $class->{VariableName}->X($className);
697 0 return $variableName;
698 }
699  
700 0 ▶sub PT::ArrayEach::X {
Subroutine X: not called CC=1 SCAR=6.9
701 0 my ($class, $className) = @_;
702  
703 0 my $variableName = $class->{VariableName}->X($className);
704 0 my $arrayEachVariableName = $class->{ArrayEachVariableName}->X($className);
705 0 my $codeBlock = $class->{CodeBlock}->X($className);
706  
707 0 my $arrayEach = "\n foreach my " . $arrayEachVariableName . "( \@{" . $variableName . "})" . $codeBlock;
708 0 return $arrayEach;
709 }
710  
711 0 ▶sub PT::ArrayEachVariableName::X {
Subroutine X: not called CC=1 SCAR=6.9
712 0 my ($class, $className) = @_;
713  
714 0 my $variableName = $class->{VariableName}->X($className);
715 0 return $variableName;
716 }
717  
718 0 ▶sub PT::HashEach::X {
Subroutine X: not called CC=1 SCAR=6.9
719 0 my ($class, $className) = @_;
720  
721 0 my $variableName = $class->{VariableName}->X($className);
722 0 my $hashEachKey = $class->{HashEachKey}->X($className);
723 0 my $hashEachValue = $class->{HashEachValue}->X($className);
724 0 my $codeBlock = $class->{CodeBlock}->X($className);
725  
726 0 my $hashEach = "\n keys %{" . $variableName . "};\n while(my (" . $hashEachKey
727 . ", " . $hashEachValue . ") = each %{ " . $variableName . " }) " . $codeBlock;
728  
729 0 return $hashEach;
730 }
731  
732 0 ▶sub PT::HashEachKey::X {
Subroutine X: not called CC=1 SCAR=6.9
733 0 my ($class, $className) = @_;
734  
735 0 my $hashEachKey = $class->{VariableName}->X($className);
736 0 return $hashEachKey;
737 }
738  
739 0 ▶sub PT::HashEachValue::X {
Subroutine X: not called CC=1 SCAR=6.9
740 0 my ($class, $className) = @_;
741  
742 0 my $hashEachValue = $class->{VariableName}->X($className);
743 0 return $hashEachValue;
744 }
745  
746 0 ▶sub PT::For::X {
Subroutine X: not called CC=1 SCAR=6.9
747 0 my ($class, $className) = @_;
748  
749 0 my $variableName = $class->{VariableName}->X($className);
750 0 my @forRange = $class->{ForRange}->X($className);
751 0 my $codeBlock = $class->{CodeBlock}->X($className);
752  
753 0 my $for = "\n for my " . $variableName . " ( " . $forRange[0]
754 . " ... " . $forRange[1] . " ) " . $codeBlock;
755  
756 0 return $for;
757 }
758  
759 0 ▶sub PT::ForRange::X {
Subroutine X: not called CC=1 SCAR=6.9
760 0 my ($class, $className) = @_;
761  
762 0 my $lowerRange = $class->{LowerRange}->X($className);
763 0 my $upperRange = $class->{UpperRange}->X($className);
764  
765 0 my @forRange = ($lowerRange, $upperRange);
766 0 return @forRange;
767 }
768  
769 0 ▶sub PT::LowerRange::X {
Subroutine X: not called CC=7 SCAR=40.3
770 0 my ($class, $className) = @_;
771  
772 my $number = ( $class->{Number}
773 || $class->{VariableName}
774 || $class->{ArrayElement}
775 || $class->{HashElement}
776 || $class->{ClassAccessor}
777 || $class->{ClassFunctionReturn}
778 0 ▶ || $class->{FunctionReturn} )->X($className);
Condition0%0/18
$class->{'Number'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
MC/DC0%0/7
$class->{'Number'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'}
$class->{"Number"} $class->{"VariableName"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"ClassAccessor"} $class->{"ClassFunctionReturn"} $class->{'FunctionReturn'}
Truth table0%0/8
A or B or C or D or E or F || G
A= $class->{"Number"}B= $class->{"VariableName"}C= $class->{"ArrayElement"}D= $class->{"HashElement"}E= $class->{"ClassAccessor"}F= $class->{"ClassFunctionReturn"}G= $class->{'FunctionReturn'}
ABCDEFGresult
1XXXXXX1
01XXXXX1
001XXXX1
0001XXX1
00001XX1
000001X1
00000011
00000000
779  
780 0 return $number;
781 }
782  
783 0 ▶sub PT::UpperRange::X {
Subroutine X: not called CC=7 SCAR=40.3
784 0 my ($class, $className) = @_;
785  
786 my $number = ( $class->{Number}
787 || $class->{VariableName}
788 || $class->{ArrayElement}
789 || $class->{HashElement}
790 || $class->{ClassAccessor}
791 || $class->{ClassFunctionReturn}
792 0 ▶ || $class->{FunctionReturn} )->X($className);
Condition0%0/18
$class->{'Number'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
MC/DC0%0/7
$class->{'Number'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'}
$class->{"Number"} $class->{"VariableName"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"ClassAccessor"} $class->{"ClassFunctionReturn"} $class->{'FunctionReturn'}
Truth table0%0/8
A or B or C or D or E or F || G
A= $class->{"Number"}B= $class->{"VariableName"}C= $class->{"ArrayElement"}D= $class->{"HashElement"}E= $class->{"ClassAccessor"}F= $class->{"ClassFunctionReturn"}G= $class->{'FunctionReturn'}
ABCDEFGresult
1XXXXXX1
01XXXXX1
001XXXX1
0001XXX1
00001XX1
000001X1
00000011
00000000
793  
794 0 return $number;
795 }
796  
797 0 ▶sub PT::IfElse::X {
Subroutine X: not called CC=5 SCAR=34.0
798 0 my ($class, $className) = @_;
799 0 my $if = $class->{If}->X($className);
800  
801 0 my $elsif;
802 my $else;
803  
804 0 ▶ if( exists $class->{ElsIf} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"ElsIf"}) 0 0 0
805 0 $elsif = $class->{ElsIf}->X($className);
806 }
807 0 ▶ if( exists $class->{Else} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Else"}) 0 0 0
808 0 $else = $class->{Else}->X($className);
809 }
810  
811 0 my $ifElseIf;
812 0 ▶ if (defined $elsif) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $elsif) 0 0 0
813 0 $ifElseIf = $if . $elsif . $else;
814 0 return $ifElseIf;
815 }
816 0 ▶ if (defined $else) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $else) 0 0 0
817 0 $ifElseIf = $if . $else;
818 0 return $ifElseIf;
819 }
820  
821 0 $ifElseIf = $if;
822 0 return $ifElseIf;
823 }
824  
825 0 ▶sub PT::IfElseIf::X {
Subroutine X: not called CC=5 SCAR=34.0
826 0 my ($class, $className) = @_;
827 0 my $if = $class->{If}->X($className);
828  
829 0 my $elsif;
830 my $else;
831  
832 0 ▶ if( exists $class->{ElsIf} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"ElsIf"}) 0 0 0
833 0 $elsif = $class->{ElsIf}->X($className);
834 }
835 0 ▶ if( exists $class->{Else} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Else"}) 0 0 0
836 0 $else = $class->{Else}->X($className);
837 }
838  
839 0 my $ifElseIf;
840 0 ▶ if (defined $elsif) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $elsif) 0 0 0
841 0 $ifElseIf = $if . $elsif . $else;
842 0 return $ifElseIf;
843 }
844 0 ▶ if (defined $else) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $else) 0 0 0
845 0 $ifElseIf = $if . $else;
846 0 return $ifElseIf;
847 }
848  
849 0 $ifElseIf = $if;
850 0 return $ifElseIf;
851 }
852  
853 0 ▶sub PT::If::X {
Subroutine X: not called CC=1 SCAR=6.9
854 0 my ($class, $className) = @_;
855  
856 0 my $boolExpression = $class->{BoolExpression}->X($className);
857 0 my $codeBlock = $class->{CodeBlock}->X($className);
858  
859 0 my $if = "\n if ( " . $boolExpression . " ) " . $codeBlock;
860 0 return $if;
861 }
862  
863 0 ▶sub PT::BoolExpression::X {
Subroutine X: not called CC=4 SCAR=30.0
864 0 my ($class, $className) = @_;
865 0 my @booleanExpressions;
866  
867 0 for my $element ( @{ $class->{BooleanExpression}} ) {
868 0 push @booleanExpressions, $element->X($className);
869 }
870  
871 0 my @boolOperators;
872  
873 0 for my $element (@{ $class->{BoolOperator} }) {
874 0 push @boolOperators, $element->X($className);
875 }
876  
877 0 my $boolExpression = $booleanExpressions[0];
878 0 for my $counter (1 .. $#booleanExpressions) {
879 0 $boolExpression .= $boolOperators[$counter - 1] . " " . $booleanExpressions[$counter];
880 }
881  
882 0 return $boolExpression;
883 }
884  
885 0 ▶sub PT::BooleanExpression::X {
Subroutine X: not called CC=2 SCAR=17.9
886 0 my ($class, $className) = @_;
887 0 my $boolExpression;
888  
889 0 my $boolOperand = $class->{BoolOperands}->X($className);
890 0 ▶ if( exists $class->{BoolOperatorExpression} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"BoolOperatorExpression"}) 0 0 0
891 0 my @boolOperatorExpression = $class->{BoolOperatorExpression}->X($className);
892 0 $boolExpression = $boolOperand . " "
893 . $boolOperatorExpression[0] . " " . $boolOperatorExpression[1];
894 0 return $boolExpression;
895 }
896  
897 0 $boolExpression = $boolOperand;
898 0 return $boolExpression;
899 }
900  
901 0 ▶sub PT::BoolOperatorExpression::X {
Subroutine X: not called CC=1 SCAR=6.9
902 0 my ($class, $className) = @_;
903  
904 0 my $boolOperator = $class->{BoolOperator}->X($className);
905 0 my $boolOperand = $class->{BoolOperands}->X($className);
906  
907 0 my @boolOperatorExpression = ($boolOperator, $boolOperand);
908 0 return @boolOperatorExpression;
909 }
910  
911 0 ▶sub PT::BoolOperator::X {
Subroutine X: not called CC=11 SCAR=48.8
912 0 my ($class, $className) = @_;
913 return ( $class->{GreaterThan}
914 || $class->{LessThan}
915 || $class->{Equals}
916 || $class->{GreaterThanEquals}
917 || $class->{LessThanEquals}
918 || $class->{StringEquals}
919 || $class->{StringNotEquals}
920 || $class->{NotEqulas}
921 || $class->{LogicalAnd}
922 || $class->{LogicalOr}
923 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/30
$class->{'GreaterThan'} || $class->{'LessThan'} || $class->{'Equals'} || $class->{'GreaterThanEquals'} || $class->{'LessThanEquals'} || $class->{'StringEquals'} || $class->{'StringNotEquals'} || $class->{'NotEqulas'} || $class->{'LogicalAnd'} || $class->{'LogicalOr'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"} or $class->{"StringEquals"} or $class->{"StringNotEquals"} or $class->{"NotEqulas"} or $class->{"LogicalAnd"} or $class->{"LogicalOr"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"} or $class->{"StringEquals"} or $class->{"StringNotEquals"} or $class->{"NotEqulas"} or $class->{"LogicalAnd"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"} or $class->{"StringEquals"} or $class->{"StringNotEquals"} or $class->{"NotEqulas"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"} or $class->{"StringEquals"} or $class->{"StringNotEquals"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"} or $class->{"StringEquals"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"} or $class->{"LessThanEquals"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"} or $class->{"GreaterThanEquals"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"} or $class->{"Equals"}
l!l&&r!l&&!r
000
$class->{"GreaterThan"} or $class->{"LessThan"}
l!l&&r!l&&!r
000
MC/DC0%0/11
$class->{'GreaterThan'} || $class->{'LessThan'} || $class->{'Equals'} || $class->{'GreaterThanEquals'} || $class->{'LessThanEquals'} || $class->{'StringEquals'} || $class->{'StringNotEquals'} || $class->{'NotEqulas'} || $class->{'LogicalAnd'} || $class->{'LogicalOr'} || $class->{'EmbedBlock'}
$class->{"GreaterThan"} $class->{"LessThan"} $class->{"Equals"} $class->{"GreaterThanEquals"} $class->{"LessThanEquals"} $class->{"StringEquals"} $class->{"StringNotEquals"} $class->{"NotEqulas"} $class->{"LogicalAnd"} $class->{"LogicalOr"} $class->{'EmbedBlock'}
Truth table0%0/12
A or B or C or D or E or F or G or H or I or J || K
A= $class->{"GreaterThan"}B= $class->{"LessThan"}C= $class->{"Equals"}D= $class->{"GreaterThanEquals"}E= $class->{"LessThanEquals"}F= $class->{"StringEquals"}G= $class->{"StringNotEquals"}H= $class->{"NotEqulas"}I= $class->{"LogicalAnd"}J= $class->{"LogicalOr"}K= $class->{'EmbedBlock'}
ABCDEFGHIJKresult
1XXXXXXXXXX1
01XXXXXXXXX1
001XXXXXXXX1
0001XXXXXXX1
00001XXXXXX1
000001XXXXX1
0000001XXXX1
00000001XXX1
000000001XX1
0000000001X1
000000000011
000000000000
924 }
925  
926 0 ▶sub PT::BoolOperands::X {
Subroutine X: not called CC=10 SCAR=47.0
927 0 my ($class, $className) = @_;
928 return ( $class->{RealNumber}
929 || $class->{String}
930 || $class->{ScalarVariable}
931 || $class->{ArrayElement}
932 || $class->{HashElement}
933 || $class->{ClassAccessor}
934 || $class->{ClassFunctionReturn}
935 || $class->{FunctionReturn}
936 || $class->{GroupAccess}
937 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/27
$class->{'RealNumber'} || $class->{'String'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'GroupAccess'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"GroupAccess"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ScalarVariable"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"}
l!l&&r!l&&!r
000
MC/DC0%0/10
$class->{'RealNumber'} || $class->{'String'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'GroupAccess'} || $class->{'EmbedBlock'}
$class->{"RealNumber"} $class->{"String"} $class->{"ScalarVariable"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"ClassAccessor"} $class->{"ClassFunctionReturn"} $class->{"FunctionReturn"} $class->{"GroupAccess"} $class->{'EmbedBlock'}
Truth table0%0/11
A or B or C or D or E or F or G or H or I || J
A= $class->{"RealNumber"}B= $class->{"String"}C= $class->{"ScalarVariable"}D= $class->{"ArrayElement"}E= $class->{"HashElement"}F= $class->{"ClassAccessor"}G= $class->{"ClassFunctionReturn"}H= $class->{"FunctionReturn"}I= $class->{"GroupAccess"}J= $class->{'EmbedBlock'}
ABCDEFGHIJresult
1XXXXXXXXX1
01XXXXXXXX1
001XXXXXXX1
0001XXXXXX1
00001XXXXX1
000001XXXX1
0000001XXX1
00000001XX1
000000001X1
00000000011
00000000000
938 }
939  
940 0 ▶sub PT::ElsIf::X {
Subroutine X: not called CC=3 SCAR=24.8
941 0 my ($class, $className) = @_;
942 0 my @elsIfChain;
943  
944 0 for my $element ( @{$class->{ElsIfChain}} ) {
945 0 push @elsIfChain, $element->X($className);
946 }
947  
948 0 my $elsIfChain;
949 0 foreach my $elsIf (@elsIfChain) {
950 0 $elsIfChain .= $elsIf;
951 }
952  
953 0 return $elsIfChain;
954 }
955  
956 0 ▶sub PT::ElsIfChain::X {
Subroutine X: not called CC=1 SCAR=6.9
957 0 my ($class, $className) = @_;
958 0 my $boolExpression = $class->{BoolExpression}->X($className);
959 0 my $codeBlock = $class->{CodeBlock}->X($className);
960  
961 0 my $elsIf = "\n elsif ( " . $boolExpression . " ) " . $codeBlock;
962 0 return $elsIf;
963 }
964  
965 0 ▶sub PT::Else::X {
Subroutine X: not called CC=1 SCAR=6.9
966 0 my ($class, $className) = @_;
967 0 my $codeBlock = $class->{CodeBlock}->X($className);
968  
969 0 my $else = "\n else " . $codeBlock;
970 0 return $else;
971 }
972  
973 0 ▶sub PT::Statement::X {
Subroutine X: not called CC=11 SCAR=48.8
974 0 my ($class, $className) = @_;
975 return ( $class->{VariableDeclaration}
976 || $class->{FunctionCall}
977 || $class->{Assignment}
978 || $class->{Regex}
979 || $class->{MakeGroup}
980 || $class->{ClassFunctionCall}
981 || $class->{FunctionReferenceCall}
982 || $class->{Return}
983 || $class->{Last}
984 || $class->{Next}
985 0 ▶ || $class->{ObjectCall} )->X($className);
Condition0%0/30
$class->{'VariableDeclaration'} || $class->{'FunctionCall'} || $class->{'Assignment'} || $class->{'Regex'} || $class->{'MakeGroup'} || $class->{'ClassFunctionCall'} || $class->{'FunctionReferenceCall'} || $class->{'Return'} || $class->{'Last'} || $class->{'Next'} || $class->{'ObjectCall'}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"} or $class->{"ClassFunctionCall"} or $class->{"FunctionReferenceCall"} or $class->{"Return"} or $class->{"Last"} or $class->{"Next"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"} or $class->{"ClassFunctionCall"} or $class->{"FunctionReferenceCall"} or $class->{"Return"} or $class->{"Last"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"} or $class->{"ClassFunctionCall"} or $class->{"FunctionReferenceCall"} or $class->{"Return"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"} or $class->{"ClassFunctionCall"} or $class->{"FunctionReferenceCall"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"} or $class->{"ClassFunctionCall"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"} or $class->{"MakeGroup"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"} or $class->{"Regex"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"} or $class->{"Assignment"}
l!l&&r!l&&!r
000
$class->{"VariableDeclaration"} or $class->{"FunctionCall"}
l!l&&r!l&&!r
000
MC/DC0%0/11
$class->{'VariableDeclaration'} || $class->{'FunctionCall'} || $class->{'Assignment'} || $class->{'Regex'} || $class->{'MakeGroup'} || $class->{'ClassFunctionCall'} || $class->{'FunctionReferenceCall'} || $class->{'Return'} || $class->{'Last'} || $class->{'Next'} || $class->{'ObjectCall'}
$class->{"VariableDeclaration"} $class->{"FunctionCall"} $class->{"Assignment"} $class->{"Regex"} $class->{"MakeGroup"} $class->{"ClassFunctionCall"} $class->{"FunctionReferenceCall"} $class->{"Return"} $class->{"Last"} $class->{"Next"} $class->{'ObjectCall'}
Truth table0%0/12
A or B or C or D or E or F or G or H or I or J || K
A= $class->{"VariableDeclaration"}B= $class->{"FunctionCall"}C= $class->{"Assignment"}D= $class->{"Regex"}E= $class->{"MakeGroup"}F= $class->{"ClassFunctionCall"}G= $class->{"FunctionReferenceCall"}H= $class->{"Return"}I= $class->{"Last"}J= $class->{"Next"}K= $class->{'ObjectCall'}
ABCDEFGHIJKresult
1XXXXXXXXXX1
01XXXXXXXXX1
001XXXXXXXX1
0001XXXXXXX1
00001XXXXXX1
000001XXXXX1
0000001XXXX1
00000001XXX1
000000001XX1
0000000001X1
000000000011
000000000000
986 }
987  
988 0 ▶sub PT::FunctionReferenceCall::X {
Subroutine X: not called CC=2 SCAR=17.9
989 0 my ($class, $className) = @_;
990  
991 0 my $functionName = $class->{FunctionName}->X($className);
992  
993 0 my $parametersList = "\$class";
994 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Parameters"}) 0 0 0
995 0 my @parameters = @{$class->{Parameters}->X($className)};
996 0 $parametersList = join(",", @parameters);
997 }
998  
999 0 my $functionReferenceCall = "\&\$" . $functionName . "(" . $parametersList . ");";
1000 0 return $functionReferenceCall;
1001 }
1002  
1003 0 ▶sub PT::Regex::X {
Subroutine X: not called CC=1 SCAR=6.9
1004 0 my ($class, $className) = @_;
1005
1006 0 my $regexVariable = $class->{RegexVariable}->X($className);
1007 0 my $regexp = $class->{Regexp}->X($className);
1008 0 my $modifiers = $class->{Modifiers}->X($className);
1009  
1010 0 my $regex = "my ". $regexVariable . " = qr{\n " . $regexp . "\n}" . $modifiers . ";";
1011 0 return $regex;
1012 }
1013  
1014 0 ▶sub PT::RegexVariable::X {
Subroutine X: not called CC=1 SCAR=6.9
1015 0 my ($class, $className) = @_;
1016  
1017 0 my $regexVariable = $class->{VariableName}->X($className);
1018 0 return $regexVariable;
1019 }
1020  
1021 0 ▶sub PT::Regexp::X {
Subroutine X: not called CC=1 SCAR=6.9
1022 0 my ($class, $className) = @_;
1023  
1024 0 my $regex = $class->{Pre}->X($className);
1025 0 return $regex;
1026 }
1027  
1028 0 ▶sub PT::Pre::X {
Subroutine X: not called CC=1 SCAR=6.9
1029 0 my ($class, $className) = @_;
1030  
1031 0 my $regex = $class->{''};
1032 0 return $regex;
1033 }
1034  
1035 0 ▶sub PT::Modifiers::X {
Subroutine X: not called CC=1 SCAR=6.9
1036 0 my ($class, $className) = @_;
1037  
1038 0 my $regexModifiers = $class->{RegexModifiers}->X($className);
1039 0 return $regexModifiers;
1040 }
1041  
1042 0 ▶sub PT::RegexModifiers::X {
Subroutine X: not called CC=1 SCAR=6.9
1043 0 my ($class, $className) = @_;
1044  
1045 0 my $regexModifiers = $class->{''};
1046 0 return $regexModifiers;
1047 }
1048  
1049 0 ▶sub PT::ObjectCall::X {
Subroutine X: not called CC=1 SCAR=6.9
1050 0 my ($class, $className) = @_;
1051 0 my $objectCall = "";
1052  
1053 0 $objectCall .= $class->{ObjectFunctionCall}->X($className);
1054 0 $objectCall .= ";\n";
1055  
1056 0 return $objectCall;
1057 }
1058  
1059 0 ▶sub PT::VariableDeclaration::X {
Subroutine X: not called CC=3 SCAR=24.8
1060 0 my ($class, $className) = @_;
1061 return ( $class->{ScalarDeclaration}
1062 || $class->{ArrayDeclaration}
1063 0 ▶ || $class->{HashDeclaration} )->X($className);
Condition0%0/6
$class->{'ScalarDeclaration'} || $class->{'ArrayDeclaration'} || $class->{'HashDeclaration'}
l!l&&r!l&&!r
000
$class->{"ScalarDeclaration"} or $class->{"ArrayDeclaration"}
l!l&&r!l&&!r
000
MC/DC0%0/3
$class->{'ScalarDeclaration'} || $class->{'ArrayDeclaration'} || $class->{'HashDeclaration'}
$class->{"ScalarDeclaration"} $class->{"ArrayDeclaration"} $class->{'HashDeclaration'}
Truth table0%0/4
A or B || C
A= $class->{"ScalarDeclaration"}B= $class->{"ArrayDeclaration"}C= $class->{'HashDeclaration'}
ABCresult
1XX1
01X1
0011
0000
1064 }
1065  
1066 0 ▶sub PT::GroupDeclaration::X {
Subroutine X: not called CC=3 SCAR=24.8
1067 0 my ($class, $className) = @_;
1068  
1069 0 my $groupName = $class->{GroupName}->X($className);
1070 0 my @groupElements = $class->{GroupBlock}->X($className);
1071  
1072 0 $groupTable->{$groupName} = {};
1073 0 for my $element (@groupElements) {
1074 0 $groupTable->{$className}->{$groupName}->{$element} = "";
1075 }
1076  
1077 0 my $groupElementsList = "";
1078 0 foreach my $groupElement (@groupElements) {
1079 0 $groupElementsList .= $groupElement . " => '', ";
1080 }
1081  
1082 # my $groupElementsList = join(" => '', ", @groupElements);
1083 0 my $groupDeclaration = "my " . $groupName . " = {" . $groupElementsList . "};\n";
1084  
1085 0 return $groupDeclaration;
1086 }
1087  
1088 0 ▶sub PT::GroupName::X {
Subroutine X: not called CC=1 SCAR=6.9
1089 0 my ($class, $className) = @_;
1090  
1091 0 my $groupName = $class->{VariableName}->X($className);
1092 0 return $groupName;
1093 }
1094  
1095 0 ▶sub PT::GroupBlock::X {
Subroutine X: not called CC=1 SCAR=6.9
1096 0 my ($class, $className) = @_;
1097  
1098 0 my @groupElements = $class->{GroupElements}->X($className);
1099 0 return @groupElements;
1100 }
1101  
1102 0 ▶sub PT::GroupElements::X {
Subroutine X: not called CC=2 SCAR=17.9
1103 0 my ($class, $className) = @_;
1104  
1105 0 my @groupElements;
1106 0 for my $element ( @{ $class->{GroupElement} } ) {
1107 0 push @groupElements, $element->X($className);
1108 }
1109  
1110 0 return @groupElements;
1111 }
1112  
1113 0 ▶sub PT::GroupElement::X {
Subroutine X: not called CC=1 SCAR=6.9
1114 0 my ($class, $className) = @_;
1115  
1116 0 my $variableName = $class->{''};
1117 0 return $variableName;
1118 }
1119  
1120 0 ▶sub PT::MakeGroup::X {
Subroutine X: not called CC=2 SCAR=17.9
1121 0 my ($class, $className) = @_;
1122  
1123 0 my $groupName = $class->{GroupName}->X($className);
1124 0 my $groupNameObject = $class->{GroupNameObject}->X($className);
1125 0 my @groupElements = keys %{ $groupTable->{$className}->{$groupName} };
1126  
1127 # if(exists $groupTable->{groupNameObject}) {};
1128  
1129 0 my $makeGroup = "my " . $groupNameObject . " = {};\n" ;
1130 0 for my $groupElement (@groupElements) {
1131 0 $makeGroup .= $groupNameObject . "->{" . $groupElement . "} = '';\n";
1132 }
1133  
1134 0 return $makeGroup;
1135 }
1136  
1137 0 ▶sub PT::GroupNameObject::X {
Subroutine X: not called CC=1 SCAR=6.9
1138 0 my ($class, $className) = @_;
1139  
1140 0 my $groupNameObject = $class->{VariableName}->X($className);
1141 0 return $groupNameObject;
1142 }
1143  
1144 0 ▶sub PT::GroupReference::X {
Subroutine X: not called CC=1 SCAR=6.9
1145 0 my ($class, $className) = @_;
1146  
1147 0 my $groupName = $class->{GroupName}->X($className);
1148 0 my $groupReference = $groupTable->{$groupName};
1149  
1150 0 return $groupReference;
1151 }
1152  
1153 0 ▶sub PT::GroupAssignment::X {
Subroutine X: not called CC=1 SCAR=6.9
1154 0 my ($class, $className) = @_;
1155  
1156 0 my $groupAccess = $class->{GroupAccess}->X($className);
1157 0 my $rhs = $class->{RHS}->X($className);
1158  
1159 0 my $groupAssignment = "if(exists(" . $groupAccess . ")){\n";
1160 0 $groupAssignment .= $groupAccess . " = " . $rhs . ";\n";
1161 0 $groupAssignment .= "\n}\n";
1162  
1163 0 return $groupAssignment;
1164 }
1165  
1166 0 ▶sub PT::GroupAccess::X {
Subroutine X: not called CC=3 SCAR=24.8
1167 0 my ($class, $className) = @_;
1168  
1169 0 my $groupName = $class->{GroupName}->X($className);
1170  
1171 0 my @groupAccessElements;
1172 0 for my $groupElement ( @{ $class->{GroupAccessElement} }) {
1173 0 push @groupAccessElements, $groupElement->X($className);
1174 }
1175  
1176 0 my $counter = 0;
1177 0 my $groupAccess = $groupName;
1178  
1179 #if(exists $groupTable->{$groupName}->{$groupAccessElements[0]}) {
1180 0 ▶ while( $counter <= $#groupAccessElements ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($counter <= $#groupAccessElements) 0 0 0
1181 0 $groupAccess .= "->{" . $groupAccessElements[$counter] . "}";
1182 0 $counter = $counter + 1;
1183 }
1184 #}
1185  
1186 0 return $groupAccess;
1187 }
1188  
1189 0 ▶sub PT::GroupAccessElement::X {
Subroutine X: not called CC=1 SCAR=6.9
1190 0 my ($class, $className) = @_;
1191  
1192 0 my $groupElement = $class->{GroupElement}->X($className);
1193 0 return $groupElement;
1194 }
1195  
1196 0 ▶sub PT::ScalarDeclaration::X {
Subroutine X: not called CC=1 SCAR=6.9
1197 0 my ($class, $className) = @_;
1198 0 my $variableName = $class->{VariableName}->X($className);
1199 0 my $value = $class->{Value}->X($className);
1200  
1201 0 my $scalarDeclaration = "\n my " . $variableName
1202 . " = " . $value . ";\n";
1203 0 return $scalarDeclaration;
1204 }
1205  
1206 0 ▶sub PT::VariableName::X {
Subroutine X: not called CC=1 SCAR=6.9
1207 0 my ($class, $className) = @_;
1208 0 my $variableName = $class->{''};
1209 0 return "\$" . $variableName;
1210 }
1211  
1212 0 ▶sub PT::Value::X {
Subroutine X: not called CC=1 SCAR=6.9
1213 0 my ($class, $className) = @_;
1214 0 my $rhs = $class->{RHS}->X($className);
1215 0 return $rhs;
1216 }
1217  
1218 0 ▶sub PT::Number::X {
Subroutine X: not called CC=1 SCAR=6.9
1219 0 my ($class, $className) = @_;
1220 0 my $number = $class->{''};
1221 0 return $number;
1222 }
1223  
1224 0 ▶sub PT::RealNumber::X {
Subroutine X: not called CC=1 SCAR=6.9
1225 0 my ($class, $className) = @_;
1226 0 my $realNumber = $class->{''};
1227 0 return $realNumber;
1228 }
1229  
1230 0 ▶sub PT::String::X {
Subroutine X: not called CC=1 SCAR=6.9
1231 0 my ($class, $className) = @_;
1232 0 my $stringValue = $class->{StringValue}->X($className);
1233  
1234 0 my $string = "\"" . $stringValue . "\"";
1235 }
1236  
1237 0 ▶sub PT::StringValue::X {
Subroutine X: not called CC=1 SCAR=6.9
1238 0 my ($class, $className) = @_;
1239 0 my $stringValue = $class->{''};
1240 0 return $stringValue;
1241 }
1242  
1243 0 ▶sub PT::ArrayDeclaration::X {
Subroutine X: not called CC=1 SCAR=6.9
1244 0 my ($class, $className) = @_;
1245 0 my $variableName = $class->{VariableName}->X($className);
1246 0 my $arrayList = $class->{ArrayList}->X($className);
1247  
1248 0 my $arrayDeclaration = "\n my " . $variableName
1249 . " = " . $arrayList . ";\n";
1250  
1251 0 return $arrayDeclaration;
1252 }
1253  
1254 0 ▶sub PT::ArrayList::X {
Subroutine X: not called CC=1 SCAR=6.9
1255 0 my ($class, $className) = @_;
1256 0 my $arrayList = "[";
1257 0 my @listElements = $class->{ListElements}->X($className);
1258  
1259 0 $arrayList .= join(",", @listElements);
1260  
1261 0 $arrayList .= "]";
1262 0 return $arrayList;
1263 }
1264  
1265 0 ▶sub PT::ListElements::X {
Subroutine X: not called CC=2 SCAR=17.9
1266 0 my ($class, $className) = @_;
1267 0 my @listElements;
1268  
1269 0 for my $element ( @{ $class->{ListElement}} ) {
1270 0 push @listElements, $element->X($className);
1271 }
1272  
1273 0 return @listElements;
1274 }
1275  
1276 0 ▶sub PT::ListElement::X {
Subroutine X: not called CC=10 SCAR=47.0
1277 0 my ($class, $className) = @_;
1278 return ( $class->{RealNumber}
1279 || $class->{String}
1280 || $class->{ArrayList}
1281 || $class->{HashRef}
1282 || $class->{ClassFunctionReturn}
1283 || $class->{FunctionReturn}
1284 || $class->{ArrayElement}
1285 || $class->{HashElement}
1286 || $class->{VariableName}
1287 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/27
$class->{'RealNumber'} || $class->{'String'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'VariableName'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"}
l!l&&r!l&&!r
000
MC/DC0%0/10
$class->{'RealNumber'} || $class->{'String'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'VariableName'} || $class->{'EmbedBlock'}
$class->{"RealNumber"} $class->{"String"} $class->{"ArrayList"} $class->{"HashRef"} $class->{"ClassFunctionReturn"} $class->{"FunctionReturn"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"VariableName"} $class->{'EmbedBlock'}
Truth table0%0/11
A or B or C or D or E or F or G or H or I || J
A= $class->{"RealNumber"}B= $class->{"String"}C= $class->{"ArrayList"}D= $class->{"HashRef"}E= $class->{"ClassFunctionReturn"}F= $class->{"FunctionReturn"}G= $class->{"ArrayElement"}H= $class->{"HashElement"}I= $class->{"VariableName"}J= $class->{'EmbedBlock'}
ABCDEFGHIJresult
1XXXXXXXXX1
01XXXXXXXX1
001XXXXXXX1
0001XXXXXX1
00001XXXXX1
000001XXXX1
0000001XXX1
00000001XX1
000000001X1
00000000011
00000000000
1288 }
1289  
1290 0 ▶sub PT::HashDeclaration::X {
Subroutine X: not called CC=1 SCAR=6.9
1291 0 my ($class, $className) = @_;
1292 0 my $variableName = $class->{VariableName}->X($className);
1293 0 my $hashRef = $class->{HashRef}->X($className);
1294  
1295 0 my $hashDeclaration = "\n my " . $variableName
1296 . " = " . $hashRef . ";\n";
1297 }
1298  
1299 0 ▶sub PT::HashRef::X {
Subroutine X: not called CC=1 SCAR=6.9
1300 0 my ($class, $className) = @_;
1301 0 my $hashRef = "{";
1302 0 my $keyValuePairs = $class->{KeyValuePairs}->X($className);
1303 0 $hashRef .= $keyValuePairs . "}";
1304 0 return $hashRef;
1305 }
1306  
1307 0 ▶sub PT::KeyValuePairs::X {
Subroutine X: not called CC=2 SCAR=17.9
1308 0 my ($class, $className) = @_;
1309 0 my @keyValuePairs;
1310  
1311 0 my $keyValuePairs = "";
1312 0 for my $element ( @{ $class->{KeyValue}} ) {
1313 0 @keyValuePairs = ();
1314 0 push @keyValuePairs, $element->X($className);
1315 0 $keyValuePairs .= $keyValuePairs[0] . " => " . $keyValuePairs[1] . ", ";
1316 }
1317  
1318 0 return $keyValuePairs;
1319 }
1320  
1321 0 ▶sub PT::KeyValue::X {
Subroutine X: not called CC=1 SCAR=6.9
1322 0 my ($class, $className) = @_;
1323 0 my $pairKey = $class->{PairKey}->X($className);
1324 0 my $pairValue = $class->{PairValue}->X($className);
1325  
1326 0 my @keyValue = ($pairKey, $pairValue);
1327 0 return @keyValue;
1328 }
1329  
1330 0 ▶sub PT::PairKey::X {
Subroutine X: not called CC=6 SCAR=37.4
1331 0 my ($class, $className) = @_;
1332 return ( $class->{Number}
1333 || $class->{String}
1334 || $class->{ClassFunctionReturn}
1335 || $class->{FunctionReturn}
1336 || $class->{VariableName}
1337 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/15
$class->{'Number'} || $class->{'String'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'VariableName'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"String"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"String"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"String"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"String"}
l!l&&r!l&&!r
000
MC/DC0%0/6
$class->{'Number'} || $class->{'String'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'VariableName'} || $class->{'EmbedBlock'}
$class->{"Number"} $class->{"String"} $class->{"ClassFunctionReturn"} $class->{"FunctionReturn"} $class->{"VariableName"} $class->{'EmbedBlock'}
Truth table0%0/7
A or B or C or D or E || F
A= $class->{"Number"}B= $class->{"String"}C= $class->{"ClassFunctionReturn"}D= $class->{"FunctionReturn"}E= $class->{"VariableName"}F= $class->{'EmbedBlock'}
ABCDEFresult
1XXXXX1
01XXXX1
001XXX1
0001XX1
00001X1
0000011
0000000
1338 }
1339  
1340 0 ▶sub PT::PairValue::X {
Subroutine X: not called CC=10 SCAR=47.0
1341 0 my ($class, $className) = @_;
1342 return ( $class->{RealNumber}
1343 || $class->{String}
1344 || $class->{ArrayList}
1345 || $class->{HashRef}
1346 || $class->{VariableName}
1347 || $class->{ArrayElement}
1348 || $class->{HashElement}
1349 || $class->{ClassFunctionReturn}
1350 || $class->{FunctionReturn}
1351 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/27
$class->{'RealNumber'} || $class->{'String'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"VariableName"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"} or $class->{"HashRef"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"ArrayList"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"}
l!l&&r!l&&!r
000
MC/DC0%0/10
$class->{'RealNumber'} || $class->{'String'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'EmbedBlock'}
$class->{"RealNumber"} $class->{"String"} $class->{"ArrayList"} $class->{"HashRef"} $class->{"VariableName"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"ClassFunctionReturn"} $class->{"FunctionReturn"} $class->{'EmbedBlock'}
Truth table0%0/11
A or B or C or D or E or F or G or H or I || J
A= $class->{"RealNumber"}B= $class->{"String"}C= $class->{"ArrayList"}D= $class->{"HashRef"}E= $class->{"VariableName"}F= $class->{"ArrayElement"}G= $class->{"HashElement"}H= $class->{"ClassFunctionReturn"}I= $class->{"FunctionReturn"}J= $class->{'EmbedBlock'}
ABCDEFGHIJresult
1XXXXXXXXX1
01XXXXXXXX1
001XXXXXXX1
0001XXXXXX1
00001XXXXX1
000001XXXX1
0000001XXX1
00000001XX1
000000001X1
00000000011
00000000000
1352 }
1353  
1354 0 ▶sub PT::FunctionCall::X {
Subroutine X: not called CC=2 SCAR=17.9
1355 0 my ($class, $className) = @_;
1356 0 my $functionName = $class->{FunctionName}->X($className);
1357  
1358 0 my $functionCall = $functionName . "(" ;
1359  
1360 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Parameters"}) 0 0 0
1361 0 my @parameters = @{$class->{Parameters}->X($className)};
1362 0 $functionCall .= join(",", @parameters);
1363 }
1364  
1365 0 $functionCall .= ");";
1366 0 return $functionCall;
1367 }
1368  
1369 0 ▶sub PT::Parameters::X {
Subroutine X: not called CC=2 SCAR=17.9
1370 0 my ($class, $className) = @_;
1371 0 my @parameters;
1372  
1373 0 for my $element (@{ $class->{Param} }) {
1374 0 push @parameters, $element->X($className);
1375 }
1376  
1377 0 return \@parameters;
1378 }
1379  
1380 0 ▶sub PT::Param::X {
Subroutine X: not called CC=16 SCAR=56.1
1381 0 my ($class, $className) = @_;
1382 return ( $class->{RealNumber}
1383 || $class->{String}
1384 || $class->{VariableName}
1385 || $class->{ArrayElement}
1386 || $class->{HashElement}
1387 || $class->{HashRef}
1388 || $class->{GroupAccess}
1389 || $class->{FunctionReturn}
1390 || $class->{ClassFunctionReturn}
1391 || $class->{EmbedBlock}
1392 || $class->{FunctionReference}
1393 || $class->{GroupAccess}
1394 || $class->{ClassFunctionReturn}
1395 || $class->{Calc}
1396 || $class->{ParamChars}
1397 0 ▶ || $class->{ObjectFunctionCall} )->X($className);
Condition0%0/45
$class->{'RealNumber'} || $class->{'String'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'HashRef'} || $class->{'GroupAccess'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'} || $class->{'EmbedBlock'} || $class->{'FunctionReference'} || $class->{'GroupAccess'} || $class->{'ClassFunctionReturn'} || $class->{'Calc'} || $class->{'ParamChars'} || $class->{'ObjectFunctionCall'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"} or $class->{"FunctionReference"} or $class->{"GroupAccess"} or $class->{"ClassFunctionReturn"} or $class->{"Calc"} or $class->{"ParamChars"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"} or $class->{"FunctionReference"} or $class->{"GroupAccess"} or $class->{"ClassFunctionReturn"} or $class->{"Calc"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"} or $class->{"FunctionReference"} or $class->{"GroupAccess"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"} or $class->{"FunctionReference"} or $class->{"GroupAccess"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"} or $class->{"FunctionReference"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"} or $class->{"EmbedBlock"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"} or $class->{"GroupAccess"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"HashRef"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"} or $class->{"VariableName"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"String"}
l!l&&r!l&&!r
000
MC/DC0%0/16
$class->{'RealNumber'} || $class->{'String'} || $class->{'VariableName'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'HashRef'} || $class->{'GroupAccess'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'} || $class->{'EmbedBlock'} || $class->{'FunctionReference'} || $class->{'GroupAccess'} || $class->{'ClassFunctionReturn'} || $class->{'Calc'} || $class->{'ParamChars'} || $class->{'ObjectFunctionCall'}
$class->{"RealNumber"} $class->{"String"} $class->{"VariableName"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"HashRef"} $class->{"GroupAccess"} $class->{"FunctionReturn"} $class->{"ClassFunctionReturn"} $class->{"EmbedBlock"} $class->{"FunctionReference"} $class->{"GroupAccess"} $class->{"ClassFunctionReturn"} $class->{"Calc"} $class->{"ParamChars"} $class->{'ObjectFunctionCall'}
Truth table0%0/17
A or B or C or D or E or F or G or H or I or J or K or L or M or N or O || P
A= $class->{"RealNumber"}B= $class->{"String"}C= $class->{"VariableName"}D= $class->{"ArrayElement"}E= $class->{"HashElement"}F= $class->{"HashRef"}G= $class->{"GroupAccess"}H= $class->{"FunctionReturn"}I= $class->{"ClassFunctionReturn"}J= $class->{"EmbedBlock"}K= $class->{"FunctionReference"}L= $class->{"GroupAccess"}M= $class->{"ClassFunctionReturn"}N= $class->{"Calc"}O= $class->{"ParamChars"}P= $class->{'ObjectFunctionCall'}
ABCDEFGHIJKLMNOPresult
1XXXXXXXXXXXXXXX1
01XXXXXXXXXXXXXX1
001XXXXXXXXXXXXX1
0001XXXXXXXXXXXX1
00001XXXXXXXXXXX1
000001XXXXXXXXXX1
0000001XXXXXXXXX1
00000001XXXXXXXX1
000000001XXXXXXX1
0000000001XXXXXX1
00000000001XXXXX1
000000000001XXXX1
0000000000001XXX1
00000000000001XX1
000000000000001X1
00000000000000011
00000000000000000
1398 }
1399  
1400 0 ▶sub PT::ParamChars::X {
Subroutine X: not called CC=1 SCAR=6.9
1401 0 my ($class, $className) = @_;
1402 0 my $paramChars = $class->{''};
1403 0 return $paramChars;
1404 }
1405  
1406 0 ▶sub PT::Assignment::X {
Subroutine X: not called CC=5 SCAR=34.0
1407 0 my ($class, $className) = @_;
1408 return ( $class->{ScalarAssignment}
1409 || $class->{ArrayAssignment}
1410 || $class->{GroupAssignment}
1411 || $class->{HashAssignment}
1412 0 ▶ || $class->{AccessorAssignment} )->X($className);
Condition0%0/12
$class->{'ScalarAssignment'} || $class->{'ArrayAssignment'} || $class->{'GroupAssignment'} || $class->{'HashAssignment'} || $class->{'AccessorAssignment'}
l!l&&r!l&&!r
000
$class->{"ScalarAssignment"} or $class->{"ArrayAssignment"} or $class->{"GroupAssignment"} or $class->{"HashAssignment"}
l!l&&r!l&&!r
000
$class->{"ScalarAssignment"} or $class->{"ArrayAssignment"} or $class->{"GroupAssignment"}
l!l&&r!l&&!r
000
$class->{"ScalarAssignment"} or $class->{"ArrayAssignment"}
l!l&&r!l&&!r
000
MC/DC0%0/5
$class->{'ScalarAssignment'} || $class->{'ArrayAssignment'} || $class->{'GroupAssignment'} || $class->{'HashAssignment'} || $class->{'AccessorAssignment'}
$class->{"ScalarAssignment"} $class->{"ArrayAssignment"} $class->{"GroupAssignment"} $class->{"HashAssignment"} $class->{'AccessorAssignment'}
Truth table0%0/6
A or B or C or D || E
A= $class->{"ScalarAssignment"}B= $class->{"ArrayAssignment"}C= $class->{"GroupAssignment"}D= $class->{"HashAssignment"}E= $class->{'AccessorAssignment'}
ABCDEresult
1XXXX1
01XXX1
001XX1
0001X1
000011
000000
1413 }
1414  
1415 0 ▶sub PT::AccessorAssignment::X {
Subroutine X: not called CC=1 SCAR=6.9
1416 0 my ($class, $className) = @_;
1417  
1418 0 my $variableName = $class->{HashKeyStringValue}->X($className);
1419 0 my $rhs = $class->{RHS}->X($className);
1420  
1421 0 my $accessorAssignment = '$class->{"' . $className . '"}->{"'. $variableName .'"} = ' . $rhs .';';
1422 0 return $accessorAssignment;
1423 }
1424  
1425 0 ▶sub PT::ScalarAssignment::X {
Subroutine X: not called CC=1 SCAR=6.9
1426 0 my ($class, $className) = @_;
1427 0 my $lhs = $class->{ScalarVariable}->X($className);
1428 0 my $rhs = $class->{RHS}->X($className);
1429  
1430 0 my $scalarAssignment = $lhs . " = " . $rhs . ";\n";
1431 0 return $scalarAssignment;
1432 }
1433  
1434 0 ▶sub PT::LHS::X {
Subroutine X: not called CC=1 SCAR=6.9
1435 0 my ($class, $className) = @_;
1436 0 my $scalarVariable = $class->{ScalarVariable}->X($className);
1437  
1438 0 return $scalarVariable;
1439 }
1440  
1441 0 ▶sub PT::ScalarVariable::X {
Subroutine X: not called CC=1 SCAR=6.9
1442 0 my ($class, $className) = @_;
1443  
1444 0 my $scalarVariable = "\$";
1445 0 $scalarVariable .= $class->{''};
1446  
1447 0 return $scalarVariable;
1448 }
1449  
1450 0 ▶sub PT::RHS::X {
Subroutine X: not called CC=19 SCAR=59.4
1451 0 my ($class, $className) = @_;
1452  
1453 return ( $class->{RealNumber}
1454 || $class->{FunctionReturn}
1455 || $class->{ArrayElement}
1456 || $class->{HashElement}
1457 || $class->{ScalarVariable}
1458 || $class->{Calc}
1459 || $class->{RegexMatchVariables}
1460 || $class->{ArrayList}
1461 || $class->{HashRef}
1462 || $class->{GroupReference}
1463 || $class->{GroupElement}
1464 || $class->{GroupAccess}
1465 || $class->{FunctionReference}
1466 || $class->{ClassAccessor}
1467 || $class->{ClassFunctionReturn}
1468 || $class->{String}
1469 || $class->{STDIN}
1470 || $class->{ObjectFunctionCall}
1471 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/54
$class->{'RealNumber'} || $class->{'FunctionReturn'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ScalarVariable'} || $class->{'Calc'} || $class->{'RegexMatchVariables'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'GroupReference'} || $class->{'GroupElement'} || $class->{'GroupAccess'} || $class->{'FunctionReference'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'String'} || $class->{'STDIN'} || $class->{'ObjectFunctionCall'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"String"} or $class->{"STDIN"} or $class->{"ObjectFunctionCall"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"String"} or $class->{"STDIN"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"String"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"} or $class->{"ClassAccessor"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"} or $class->{"FunctionReference"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"} or $class->{"GroupAccess"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"} or $class->{"GroupElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"} or $class->{"GroupReference"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"} or $class->{"HashRef"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"} or $class->{"ArrayList"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"} or $class->{"RegexMatchVariables"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"} or $class->{"Calc"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ScalarVariable"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
MC/DC0%0/19
$class->{'RealNumber'} || $class->{'FunctionReturn'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ScalarVariable'} || $class->{'Calc'} || $class->{'RegexMatchVariables'} || $class->{'ArrayList'} || $class->{'HashRef'} || $class->{'GroupReference'} || $class->{'GroupElement'} || $class->{'GroupAccess'} || $class->{'FunctionReference'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'String'} || $class->{'STDIN'} || $class->{'ObjectFunctionCall'} || $class->{'EmbedBlock'}
too many conditions
1472 }
1473  
1474 0 ▶sub PT::RegexMatchVariables::X {
Subroutine X: not called CC=5 SCAR=34.0
1475 0 my ($class, $className) = @_;
1476  
1477 0 my $matchVariable = $class->{MatchVariable}->X($className);
1478 0 my $regexMatchVariables = "";
1479  
1480 0 ▶ if( $matchVariable =~ /\d+/ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($matchVariable =~ /\d+/) 0 0 0
1481 0 $regexMatchVariables = "\$" . $matchVariable;
1482 }
1483  
1484 0 ▶ if( $matchVariable eq "Match" ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($matchVariable eq "Match") 0 0 0
1485 0 $regexMatchVariables = "\$" . "\&";
1486 }
1487  
1488 0 ▶ if( $matchVariable eq "PREMATCH" ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($matchVariable eq "PREMATCH") 0 0 0
1489 0 $regexMatchVariables = "\$" . "\'";
1490 }
1491  
1492 0 ▶ if( $matchVariable eq "POSTMATCH" ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($matchVariable eq "POSTMATCH") 0 0 0
1493 0 $regexMatchVariables = "\$" . "\`";
1494 }
1495  
1496 0 return $regexMatchVariables;
1497 }
1498  
1499 0 ▶sub PT::MatchVariable::X {
Subroutine X: not called CC=2 SCAR=17.9
1500 0 my ($class, $className) = @_;
1501  
1502 return ( $class->{Number}
1503 0 ▶ || $class->{MatchParts} )->X($className);
Condition0%0/3
$class->{'Number'} || $class->{'MatchParts'}
l!l&&r!l&&!r
000
MC/DC0%0/2
$class->{'Number'} || $class->{'MatchParts'}
$class->{'Number'} $class->{'MatchParts'}
Truth table0%0/3
A || B
A= $class->{'Number'}B= $class->{'MatchParts'}
ABresult
1X1
011
000
1504 }
1505  
1506 0 ▶sub PT::MatchParts::X {
Subroutine X: not called CC=1 SCAR=6.9
1507 0 my ($class, $className) = @_;
1508 0 return $class->{''};
1509 }
1510  
1511 0 ▶sub PT::FunctionReference::X {
Subroutine X: not called CC=1 SCAR=6.9
1512 0 my ($class, $className) = @_;
1513  
1514 0 my $functionName = $class->{FunctionName}->X($className);
1515 0 my $functionReference = "\\&" . $functionName;
1516 0 return $functionReference;
1517 }
1518  
1519 0 ▶sub PT::STDIN::X {
Subroutine X: not called CC=1 SCAR=6.9
1520 0 my ($class, $className) = @_;
1521 0 my $stdin = '<STDIN>';
1522 0 return $stdin;
1523 }
1524  
1525 0 ▶sub PT::ObjectFunctionCall::X {
Subroutine X: not called CC=2 SCAR=17.9
1526 0 my ($class, $className) = @_;
1527  
1528 0 my $object = $class->{Object}->X($className);
1529 0 my $functionName = $class->{FunctionName}->X($className);
1530  
1531 0 my $objectFunctionCall;
1532 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{'Parameters'}) { } 0 0 0
1533 0 my @parameters = @{$class->{Parameters}->X($className)};
1534 0 my $parameters = join(",", @parameters);
1535 0 $objectFunctionCall = "\$" . $object . "->" . $functionName . "(" . $parameters . ")";
1536 } else {
1537 0 $objectFunctionCall = "\$" . $object . "->" . $functionName . "()";
1538 }
1539  
1540 0 return $objectFunctionCall;
1541 }
1542  
1543 0 ▶sub PT::ClassAccessor::X {
Subroutine X: not called CC=1 SCAR=6.9
1544 0 my ($class, $className) = @_;
1545 0 my $variableName = $class->{HashKeyStringValue}->X($className);
1546  
1547 0 my $classAccessor = '$class->{"' . $className . '"}->{"'. $variableName .'"}';
1548 0 return $classAccessor;
1549 }
1550  
1551 0 ▶sub PT::ClassFunctionCall::X {
Subroutine X: not called CC=2 SCAR=17.9
1552 0 my ($class, $className) = @_;
1553 0 my $functionName = $class->{FunctionName}->X($className);
1554 0 my @parameters;
1555 0 my $parameters = "";
1556 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Parameters"}) 0 0 0
1557 0 @parameters = @{$class->{Parameters}->X($className)};
1558 0 $parameters = join(",", @parameters);
1559 }
1560  
1561 0 my $classFunctionReturn = '$class->' . $functionName . '('. $parameters .');';
1562 0 return $classFunctionReturn;
1563 }
1564  
1565 0 ▶sub PT::ClassFunctionReturn::X {
Subroutine X: not called CC=2 SCAR=17.9
1566 0 my ($class, $className) = @_;
1567 0 my $functionName = $class->{FunctionName}->X($className);
1568 0 my @parameters;
1569 0 my $parameters = "";
1570  
1571 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Parameters"}) 0 0 0
1572 0 @parameters = @{$class->{Parameters}->X($className)};
1573 0 $parameters = join(",", @parameters);
1574 }
1575  
1576 0 my $classFunctionReturn = '$class->' . $functionName . '('. $parameters .')';
1577 0 return $classFunctionReturn;
1578 }
1579  
1580 0 ▶sub PT::FunctionReturn::X {
Subroutine X: not called CC=2 SCAR=17.9
1581 0 my ($class, $className) = @_;
1582 0 my $functionName = $class->{FunctionName}->X($className);
1583  
1584 0 my $functionReturn = $functionName . "(" ;
1585  
1586 0 ▶ if(exists $class->{Parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{"Parameters"}) 0 0 0
1587 0 my @parameters = @{$class->{Parameters}->X($className)};
1588 0 my $parameters = join(",", @parameters);
1589 0 $functionReturn .= $parameters;
1590 }
1591  
1592 0 $functionReturn .= ")";
1593 0 return $functionReturn;
1594 }
1595  
1596 0 ▶sub PT::ArrayElement::X {
Subroutine X: not called CC=3 SCAR=24.8
1597 0 my ($class, $className) = @_;
1598 0 my $arrayName = $class->{ArrayName}->X($className);
1599 0 my @accessList;
1600  
1601 0 for my $element (@{ $class->{ArrayAccess} }) {
1602 0 push @accessList, $element->X($className);
1603 }
1604  
1605 0 my $arrayElement = "\$" . $arrayName;
1606 0 foreach my $element (@accessList) {
1607 0 $arrayElement .= "->[" . $element . "]";
1608 }
1609  
1610 0 return $arrayElement;
1611 }
1612  
1613 0 ▶sub PT::ArrayAccess::X {
Subroutine X: not called CC=1 SCAR=6.9
1614 0 my ($class, $className) = @_;
1615 0 my $number = $class->{ArrayKey}->X($className);
1616 0 return $number;
1617 }
1618  
1619 0 ▶sub PT::ArrayKey::X {
Subroutine X: not called CC=6 SCAR=37.4
1620 0 my ($class, $className) = @_;
1621 return ( $class->{Number}
1622 || $class->{ScalarVariable}
1623 || $class->{ArrayElement}
1624 || $class->{HashElement}
1625 || $class->{FunctionReturn}
1626 0 ▶ || $class->{ClassFunctionReturn} )->X($className);
Condition0%0/15
$class->{'Number'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"Number"} or $class->{"ScalarVariable"}
l!l&&r!l&&!r
000
MC/DC0%0/6
$class->{'Number'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'}
$class->{"Number"} $class->{"ScalarVariable"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"FunctionReturn"} $class->{'ClassFunctionReturn'}
Truth table0%0/7
A or B or C or D or E || F
A= $class->{"Number"}B= $class->{"ScalarVariable"}C= $class->{"ArrayElement"}D= $class->{"HashElement"}E= $class->{"FunctionReturn"}F= $class->{'ClassFunctionReturn'}
ABCDEFresult
1XXXXX1
01XXXX1
001XXX1
0001XX1
00001X1
0000011
0000000
1627 }
1628  
1629 0 ▶sub PT::ArrayName::X {
Subroutine X: not called CC=1 SCAR=6.9
1630 0 my ($class, $className) = @_;
1631 0 my $arrayName = $class->{''};
1632 0 return $arrayName;
1633 }
1634  
1635 0 ▶sub PT::HashElement::X {
Subroutine X: not called CC=3 SCAR=24.8
1636 0 my ($class, $className) = @_;
1637 0 my $hashName = $class->{HashName}->X($className);
1638 0 my @accessList;
1639  
1640 0 for my $element (@{ $class->{HashAccess} }) {
1641 0 push @accessList, $element->X($className);
1642 }
1643  
1644 0 my $hashElement = "\$" . $hashName;
1645 0 foreach my $element (@accessList) {
1646 0 $hashElement .= "->{" . $element . "}";
1647 }
1648  
1649 0 return $hashElement;
1650 }
1651  
1652 0 ▶sub PT::HashAccess::X {
Subroutine X: not called CC=1 SCAR=6.9
1653 0 my ($class, $className) = @_;
1654 0 my $hashKey = $class->{HashKey}->X($className);
1655 0 return $hashKey;
1656 }
1657  
1658 0 ▶sub PT::HashName::X {
Subroutine X: not called CC=1 SCAR=6.9
1659 0 my ($class, $className) = @_;
1660 0 my $hashName = $class->{''};
1661 0 return $hashName;
1662 }
1663  
1664 0 ▶sub PT::HashKey::X {
Subroutine X: not called CC=7 SCAR=40.3
1665 0 my ($class, $className) = @_;
1666 return ( $class->{String}
1667 || $class->{Number}
1668 || $class->{ScalarVariable}
1669 || $class->{ArrayElement}
1670 || $class->{HashElement}
1671 || $class->{FunctionReturn}
1672 0 ▶ || $class->{ClassFunctionReturn} )->X($className);
Condition0%0/18
$class->{'String'} || $class->{'Number'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'}
l!l&&r!l&&!r
000
$class->{"String"} or $class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"String"} or $class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"String"} or $class->{"Number"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"String"} or $class->{"Number"} or $class->{"ScalarVariable"}
l!l&&r!l&&!r
000
$class->{"String"} or $class->{"Number"}
l!l&&r!l&&!r
000
MC/DC0%0/7
$class->{'String'} || $class->{'Number'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'FunctionReturn'} || $class->{'ClassFunctionReturn'}
$class->{"String"} $class->{"Number"} $class->{"ScalarVariable"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"FunctionReturn"} $class->{'ClassFunctionReturn'}
Truth table0%0/8
A or B or C or D or E or F || G
A= $class->{"String"}B= $class->{"Number"}C= $class->{"ScalarVariable"}D= $class->{"ArrayElement"}E= $class->{"HashElement"}F= $class->{"FunctionReturn"}G= $class->{'ClassFunctionReturn'}
ABCDEFGresult
1XXXXXX1
01XXXXX1
001XXXX1
0001XXX1
00001XX1
000001X1
00000011
00000000
1673 }
1674  
1675 0 ▶sub PT::HashKeyString::X {
Subroutine X: not called CC=1 SCAR=6.9
1676 0 my ($class, $className) = @_;
1677  
1678 0 my $hashKeyStringValue = "\"";
1679 0 $hashKeyStringValue .= $class->{HashKeyStringValue}->X($className);
1680 0 $hashKeyStringValue .= "\"";
1681  
1682 0 return $hashKeyStringValue;
1683 }
1684  
1685 0 ▶sub PT::HashKeyStringValue::X {
Subroutine X: not called CC=1 SCAR=6.9
1686 0 my ($class, $className) = @_;
1687 0 my $hashKeyStringValue = $class->{''};
1688 0 return $hashKeyStringValue;
1689 }
1690  
1691 0 ▶sub PT::HashKeyNumber::X {
Subroutine X: not called CC=1 SCAR=6.9
1692 0 my ($class, $className) = @_;
1693 0 my $hashKeyNumber = $class->{''};
1694 0 return $hashKeyNumber;
1695 }
1696  
1697 0 ▶sub PT::ArrayAssignment::X {
Subroutine X: not called CC=1 SCAR=6.9
1698 0 my ($class, $className) = @_;
1699 0 my $arrayElement = $class->{ArrayElement}->X($className);
1700 0 my $rhs = $class->{RHS}->X($className);
1701  
1702 0 my $arrayAssignment = $arrayElement . " = " . $rhs . ";\n";
1703 0 return $arrayAssignment;
1704 }
1705  
1706 0 ▶sub PT::HashAssignment::X {
Subroutine X: not called CC=1 SCAR=6.9
1707 0 my ($class, $className) = @_;
1708 0 my $hashElement = $class->{HashElement}->X($className);
1709 0 my $rhs = $class->{RHS}->X($className);
1710  
1711 0 my $hashAssignment = $hashElement . " = " . $rhs . ";\n";
1712 0 return $hashAssignment;
1713 }
1714  
1715 0 ▶sub PT::Calc::X {
Subroutine X: not called CC=1 SCAR=6.9
1716 0 my ($class, $className) = @_;
1717 0 my $calcExpression = $class->{CalcExpression}->X($className);
1718 0 return $calcExpression;
1719 }
1720  
1721 0 ▶sub PT::CalcExpression::X {
Subroutine X: not called CC=4 SCAR=30.0
1722 0 my ($class, $className) = @_;
1723 0 my @calcOperands;
1724 my @calcOperator;
1725  
1726 0 for my $element (@{ $class->{CalcOperands} }) {
1727 0 push @calcOperands, $element->X($className);
1728 }
1729  
1730 0 for my $element (@{ $class->{CalcOperator} }) {
1731 0 push @calcOperator, $element->X($className);
1732 }
1733  
1734 0 my $calcExpression = $calcOperands[0];
1735 0 for my $counter (1 .. $#calcOperands) {
1736 0 $calcExpression .= $calcOperator[$counter - 1] . " " . $calcOperands[$counter];
1737 }
1738  
1739 0 return $calcExpression;
1740 }
1741  
1742 0 ▶sub PT::CalcOperands::X {
Subroutine X: not called CC=9 SCAR=45.0
1743 0 my ($class, $className) = @_;
1744 return ( $class->{RealNumber}
1745 || $class->{ScalarVariable}
1746 || $class->{ArrayElement}
1747 || $class->{HashElement}
1748 || $class->{ClassAccessor}
1749 || $class->{ClassFunctionReturn}
1750 || $class->{FunctionReturn}
1751 || $class->{EmbedBlock}
1752 0 ▶ || $class->{ObjectFunctionCall} )->X($className);
Condition0%0/24
$class->{'RealNumber'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'EmbedBlock'} || $class->{'ObjectFunctionCall'}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"} or $class->{"EmbedBlock"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"} or $class->{"FunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"} or $class->{"ClassFunctionReturn"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"} or $class->{"ClassAccessor"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"} or $class->{"HashElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"} or $class->{"ArrayElement"}
l!l&&r!l&&!r
000
$class->{"RealNumber"} or $class->{"ScalarVariable"}
l!l&&r!l&&!r
000
MC/DC0%0/9
$class->{'RealNumber'} || $class->{'ScalarVariable'} || $class->{'ArrayElement'} || $class->{'HashElement'} || $class->{'ClassAccessor'} || $class->{'ClassFunctionReturn'} || $class->{'FunctionReturn'} || $class->{'EmbedBlock'} || $class->{'ObjectFunctionCall'}
$class->{"RealNumber"} $class->{"ScalarVariable"} $class->{"ArrayElement"} $class->{"HashElement"} $class->{"ClassAccessor"} $class->{"ClassFunctionReturn"} $class->{"FunctionReturn"} $class->{"EmbedBlock"} $class->{'ObjectFunctionCall'}
Truth table0%0/10
A or B or C or D or E or F or G or H || I
A= $class->{"RealNumber"}B= $class->{"ScalarVariable"}C= $class->{"ArrayElement"}D= $class->{"HashElement"}E= $class->{"ClassAccessor"}F= $class->{"ClassFunctionReturn"}G= $class->{"FunctionReturn"}H= $class->{"EmbedBlock"}I= $class->{'ObjectFunctionCall'}
ABCDEFGHIresult
1XXXXXXXX1
01XXXXXXX1
001XXXXXX1
0001XXXXX1
00001XXXX1
000001XXX1
0000001XX1
00000001X1
0000000011
0000000000
1753 }
1754  
1755 0 ▶sub PT::CalcOperator::X {
Subroutine X: not called CC=5 SCAR=34.0
1756 0 my ($class, $className) = @_;
1757 return ( $class->{Plus}
1758 || $class->{Minus}
1759 || $class->{Multiply}
1760 || $class->{Divide}
1761 0 ▶ || $class->{EmbedBlock} )->X($className);
Condition0%0/12
$class->{'Plus'} || $class->{'Minus'} || $class->{'Multiply'} || $class->{'Divide'} || $class->{'EmbedBlock'}
l!l&&r!l&&!r
000
$class->{"Plus"} or $class->{"Minus"} or $class->{"Multiply"} or $class->{"Divide"}
l!l&&r!l&&!r
000
$class->{"Plus"} or $class->{"Minus"} or $class->{"Multiply"}
l!l&&r!l&&!r
000
$class->{"Plus"} or $class->{"Minus"}
l!l&&r!l&&!r
000
MC/DC0%0/5
$class->{'Plus'} || $class->{'Minus'} || $class->{'Multiply'} || $class->{'Divide'} || $class->{'EmbedBlock'}
$class->{"Plus"} $class->{"Minus"} $class->{"Multiply"} $class->{"Divide"} $class->{'EmbedBlock'}
Truth table0%0/6
A or B or C or D || E
A= $class->{"Plus"}B= $class->{"Minus"}C= $class->{"Multiply"}D= $class->{"Divide"}E= $class->{'EmbedBlock'}
ABCDEresult
1XXXX1
01XXX1
001XX1
0001X1
000011
000000
1762 }
1763  
1764 0 ▶sub PT::Return::X {
Subroutine X: not called CC=2 SCAR=17.9
1765 0 my ($class, $className) = @_;
1766 0 ▶ if(exists $class->{RHS}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $class->{'RHS'}) { } 0 0 0
1767 0 my $rhs = $class->{RHS}->X($className);
1768 0 my $return = "return " . $rhs . ";\n";
1769 0 return $return;
1770 } else {
1771 0 return "return;";
1772 }
1773 }
1774  
1775 0 ▶sub PT::Last::X {
Subroutine X: not called CC=1 SCAR=6.9
1776 0 my ($class, $className) = @_;
1777 0 return "last;";
1778 }
1779  
1780 0 ▶sub PT::Next::X {
Subroutine X: not called CC=1 SCAR=6.9
1781 0 my ($class, $className) = @_;
1782 0 return "next;";
1783 }
1784  
1785 0 ▶sub PT::GreaterThan::X {
Subroutine X: not called CC=1 SCAR=6.9
1786 0 my ($class, $className) = @_;
1787 0 my $greaterThan = $class->{''};
1788 0 return $greaterThan;
1789 }
1790  
1791 0 ▶sub PT::LessThan::X {
Subroutine X: not called CC=1 SCAR=6.9
1792 0 my ($class, $className) = @_;
1793 0 my $lessThan = $class->{''};
1794 0 return $lessThan;
1795 }
1796  
1797 0 ▶sub PT::Equals::X {
Subroutine X: not called CC=1 SCAR=6.9
1798 0 my ($class, $className) = @_;
1799 0 my $equals = $class->{''};
1800 0 return $equals;
1801 }
1802  
1803 0 ▶sub PT::Plus::X {
Subroutine X: not called CC=1 SCAR=6.9
1804 0 my ($class, $className) = @_;
1805 0 my $plus = $class->{''};
1806 0 return $plus;
1807 }
1808  
1809 0 ▶sub PT::Minus::X {
Subroutine X: not called CC=1 SCAR=6.9
1810 0 my ($class, $className) = @_;
1811 0 my $minus = $class->{''};
1812 0 return $minus;
1813 }
1814  
1815 0 ▶sub PT::Multiply::X {
Subroutine X: not called CC=1 SCAR=6.9
1816 0 my ($class, $className) = @_;
1817 0 my $multiply = $class->{''};
1818 0 return $multiply;
1819 }
1820  
1821 0 ▶sub PT::Divide::X {
Subroutine X: not called CC=1 SCAR=6.9
1822 0 my ($class, $className) = @_;
1823 0 my $divide = $class->{''};
1824 0 return $divide;
1825 }
1826  
1827 0 ▶sub PT::Modulus::X {
Subroutine X: not called CC=1 SCAR=6.9
1828 0 my ($class, $className) = @_;
1829 0 my $divide = $class->{''};
1830 0 return $divide;
1831 }
1832  
1833 0 ▶sub PT::Exponent::X {
Subroutine X: not called CC=1 SCAR=6.9
1834 0 my ($class, $className) = @_;
1835 0 my $divide = $class->{''};
1836 0 return $divide;
1837 }
1838  
1839 0 ▶sub PT::GreaterThanEquals::X {
Subroutine X: not called CC=1 SCAR=6.9
1840 0 my ($class, $className) = @_;
1841 0 my $greaterThanEquals = $class->{''};
1842 0 return $greaterThanEquals;
1843 }
1844  
1845 0 ▶sub PT::LessThanEquals::X {
Subroutine X: not called CC=1 SCAR=6.9
1846 0 my ($class, $className) = @_;
1847 0 my $lessThanEquals = $class->{''};
1848 0 return $lessThanEquals;
1849 }
1850  
1851 0 ▶sub PT::StringEquals::X {
Subroutine X: not called CC=1 SCAR=6.9
1852 0 my ($class, $className) = @_;
1853 0 my $stringEquals = $class->{''};
1854 0 return $stringEquals;
1855 }
1856  
1857 0 ▶sub PT::StringNotEquals::X {
Subroutine X: not called CC=1 SCAR=6.9
1858 0 my ($class, $className) = @_;
1859 0 my $stringNotEquals = $class->{''};
1860 0 return $stringNotEquals;
1861 }
1862  
1863 0 ▶sub PT::NotEqulas::X {
Subroutine X: not called CC=1 SCAR=6.9
1864 0 my ($class, $className) = @_;
1865 0 my $notEqulas = $class->{''};
1866 0 return $notEqulas;
1867 }
1868  
1869 0 ▶sub PT::LogicalAnd::X {
Subroutine X: not called CC=1 SCAR=6.9
1870 0 my ($class, $className) = @_;
1871 0 my $logicalAnd = $class->{''};
1872 0 return $logicalAnd;
1873 }
1874  
1875 0 ▶sub PT::LogicalOr::X {
Subroutine X: not called CC=1 SCAR=6.9
1876 0 my ($class, $className) = @_;
1877 0 my $logicalOr = $class->{''};
1878 0 return $logicalOr;
1879 }
1880  
1881 0 ▶sub PT::TokenImplement::X {
Subroutine X: not called CC=1 SCAR=6.9
1882 0 my ($class, $className) = @_;
1883 0 my $tokenImplement = $class->{''};
1884 0 return $tokenImplement;
1885 }
1886  
1887 0 ▶sub PT::TokenTry::X {
Subroutine X: not called CC=1 SCAR=6.9
1888 0 my ($class, $className) = @_;
1889 0 my $tokenTry = $class->{''};
1890 0 return $tokenTry;
1891 }
1892  
1893 0 ▶sub PT::TokenCatch::X {
Subroutine X: not called CC=1 SCAR=6.9
1894 0 my ($class, $className) = @_;
1895 0 my $tokenCatch = $class->{''};
1896 0 return $tokenCatch;
1897 }
1898  
1899 0 ▶sub PT::TokenError::X {
Subroutine X: not called CC=1 SCAR=6.9
1900 0 my ($class, $className) = @_;
1901 0 my $tokenError = $class->{''};
1902 0 return $tokenError;
1903 }
1904  
1905 0 ▶sub PT::EachSymbol::X {
Subroutine X: not called CC=1 SCAR=6.9
1906 0 my ($class, $className) = @_;
1907 0 my $eachSymbol = $class->{''};
1908 0 return $eachSymbol;
1909 }
1910  
1911 0 ▶sub PT::LBrace::X {
Subroutine X: not called CC=1 SCAR=6.9
1912 0 my ($class, $className) = @_;
1913 0 my $lBrace = $class->{''};
1914 0 return $lBrace;
1915 }
1916  
1917 0 ▶sub PT::LBraceError::X {
Subroutine X: not called CC=1 SCAR=6.9
1918 0 my ($class, $className) = @_;
1919 0 my $lBraceError = $class->{''};
1920  
1921 0 print "SyntaxError", "\n";
1922 0 print "===========", "\n";
1923 0 die "Missing { after className '", $className, "', instead found ", $lBraceError, "\n";
1924 }
1925  
1926 0 ▶sub PT::RBrace::X {
Subroutine X: not called CC=1 SCAR=6.9
1927 0 my ($class, $className) = @_;
1928 0 my $rBrace = $class->{''};
1929 0 return $rBrace;
1930 }
1931  
1932 0 ▶sub PT::RBraceError::X {
Subroutine X: not called CC=1 SCAR=6.9
1933 0 my ($class, $className) = @_;
1934 0 my $rBraceError = $class->{''};
1935  
1936 0 print "SyntaxError", "\n";
1937 0 print "===========", "\n";
1938 0 die "Missing } after class '", $className, "', instead found ", $rBraceError, "\n";
1939 }
1940  
1941 1 my $parser = qr {
1942 <nocontext:>
1943 # <debug: on>
1944  
1945 <Lang>
1946 <objrule: PT::Lang> <[Class]>+
1947  
1948 <objrule: PT::Class> <ws: (\s++)*> <TokenClass> <ClassName> <ClassBlock>
1949 <objrule: PT::ClassName> [a-zA-Z]+?
1950  
1951 <objrule: PT::ClassBlock> <ErrorLBrace> <ClassGroups> <ErrorRBrace>
1952 <objrule: PT::ErrorLBrace> <LBrace> | <LBraceError>
1953 <objrule: PT::ErrorRBrace> <RBrace> | <RBraceError>
1954  
1955 <objrule: PT::ClassGroups> <[Group]>+
1956 <objrule: PT::Group> <Comment> | <Parent> | <Packages> | <EmbedBlock> | <GroupDeclaration>
1957 | <ImplementFunction> | <Function> | <NonSyntaxClass>
1958  
1959 <objtoken: PT::NonSyntaxClass> \b.*\b
1960  
1961 <objrule: PT::ImplementFunction> <TokenImplement> <TokenFunction> <FunctionName> <LParen> <FunctionParamList> <RParen> <LBrace> <MultiLineComment>? <RBrace>
1962 <objrule: PT::MultiLineComment> <MLCommentBegin> <MLComment> <MLCommentEnd>
1963 <objtoken: PT::MLCommentBegin> \/\*
1964 <objtoken: PT::MLCommentEnd> \*\/
1965 <objrule: PT::MLComment> (?<=\/\*)\s*.*?\s*(?=\*\/)
1966  
1967 <objrule: PT::Comment> [#] <LineComment> @
1968 <objtoken: PT::LineComment> .*?
1969  
1970 <objrule: PT::Parent> <TokenParent> <LParen> <ClassNames> <RParen> <SemiColon>
1971 <objrule: PT::ClassNames> <[ClassName]>+ % <Comma>
1972  
1973 <objrule: PT::Packages> <LParen> <PackageList> <RParen> <SemiColon>
1974 <objrule: PT::PackageList> <[Package]>+ % <Comma>
1975 <objrule: PT::Package> <PackageWithConstructor> | <PackageWithoutConstructor>
1976 <objrule: PT::PackageWithConstructor> [!] <Object> <Equal> <PackageName> <Dot> <Constructor> <LParen> <ObjectParameters>? <RParen>
1977 <objrule: PT::ObjectParameters> <PackageParams> | <Parameters>
1978 <objrule: PT::PackageParams> <[KeyValue]>+ % <Comma>
1979 <objrule: PT::PackageName> <[PackageDir]>+ % (::)
1980 <objrule: PT::PackageWithoutConstructor> <PackageName> <QW>?
1981 <objrule: PT::QW> <Dot> <LParen> <FunctionList> <RParen>
1982 <objrule: PT::FunctionList> <[FunctionName]>+ % <Comma>
1983 <objrule: PT::Constructor> [a-zA-Z]+?
1984 <objrule: PT::Object> [a-zA-Z]+?
1985 <objrule: PT::PackageDir> [a-zA-Z]+?
1986  
1987 <objrule: PT::Function> <TokenFunction> <FunctionName> <LParen> <FunctionParamList> <RParen> <CodeBlock>
1988 <objtoken: PT::FunctionName> [a-zA-Z_]+?
1989  
1990 <objrule: PT::FunctionParamList> <EmptyParamList> | <FunctionParams>
1991 <objtoken: PT::EmptyParamList> .{0}
1992 <objrule: PT::FunctionParams> <[Arg]>+ % <Comma>
1993 <objrule: PT::Arg> [a-zA-Z]+?
1994  
1995 <objrule: PT::CodeBlock> <LBrace> <Blocks> <RBrace>
1996 <objrule: PT::Blocks> <[Block]>+
1997  
1998 <objrule: PT::Block> <IfElse> | <While> | <ForEach> | <For> | <ArrayEach> | <HashEach> | <EmbedBlock>
1999 | <Comment> | <Statement> | <TryCatch> | <RegexMatch> | <Packages> | <NonSyntaxFunction>
2000  
2001 <objtoken: PT::NonSyntaxFunction> \b.*\b
2002  
2003 <objrule: PT::TryCatch> <TokenTry> <CodeBlock> <CatchBlock>?
2004 <objrule: PT::CatchBlock> <TokenCatch> <LParen> <TokenError> <RParen> <CodeBlock>
2005  
2006 <objrule: PT::EmbedBlock> <TokenEmbedBlock> <EmbedCodeBlock>
2007 <objrule: PT::EmbedCodeBlock> <EmbedBegin> <EmbeddedCode> <EmbedEnd>
2008 <objrule: PT::EmbedBegin> <LParen>\?
2009 <objrule: PT::EmbedEnd> \?<RParen>
2010 <objrule: PT::EmbeddedCode> (?<=\(\?)\s*.*?\s*(?=\?\))
2011  
2012 <objrule: PT::While> <TokenWhile> <LParen> <BoolExpression> <RParen> <CodeBlock>
2013  
2014 <objrule: PT::ForEach> <TokenForeach> <LParen> <ForRange> <RParen> <EachSymbol> <VariableName> <CodeBlock>
2015  
2016 <objrule: PT::ArrayEach> <TokenArrayEach> <LParen> <VariableName> <RParen> <EachSymbol> <ArrayEachVariableName> <CodeBlock>
2017 <objrule: PT::ArrayEachVariableName> <VariableName>
2018  
2019 <objrule: PT::HashEach> <TokenHashEach> <LParen> <VariableName> <RParen> <EachSymbol> <LParen> <HashEachKey> <Comma> <HashEachValue> <RParen> <CodeBlock>
2020 <objrule: PT::HashEachKey> <VariableName>
2021 <objrule: PT::HashEachValue> <VariableName>
2022  
2023 <objrule: PT::For> <TokenFor> <Var> <VariableName> <LParen> <ForRange> <RParen> <CodeBlock>
2024 <objrule: PT::ForRange> <LowerRange> <Dot><Dot><Dot> <UpperRange>
2025  
2026 <objrule: PT::LowerRange> <Number> | <VariableName> | <ArrayElement> | <HashElement>
2027 | <ClassAccessor> | <ClassFunctionReturn> | <FunctionReturn>
2028  
2029 <objrule: PT::UpperRange> <Number> | <VariableName> | <ArrayElement> | <HashElement>
2030 | <ClassAccessor> | <ClassFunctionReturn> | <FunctionReturn>
2031  
2032 <objrule: PT::RegexMatch> <TokenMatchRegex> <LParen> <Pattern> <RegexMatchSymbol> <MatchString> <RParen> <CodeBlock>
2033 <objrule: PT::Pattern> <VariableName>
2034 <objrule: PT::MatchString> <VariableName>
2035  
2036 <objrule: PT::IfElse> <If> <ElsIf>? <Else>?
2037 <objrule: PT::If> <TokenIf> <LParen> <BoolExpression> <RParen> <CodeBlock>
2038  
2039 <objrule: PT::BoolExpression> <[BooleanExpression]>+ % <[BoolOperator]>
2040 <objrule: PT::BooleanExpression> <BoolOperands> <BoolOperatorExpression>?
2041 <objrule: PT::BoolOperatorExpression> <BoolOperator> <BoolOperands>
2042  
2043 <objrule: PT::BoolOperands> <RealNumber> | <String> | <ScalarVariable> | <ArrayElement> | <HashElement>
2044 | <ClassAccessor> | <ClassFunctionReturn> | <FunctionReturn> | <GroupAccess> | <EmbedBlock>
2045  
2046 <objrule: PT::BoolOperator> <GreaterThan> | <LessThan> | <Equals> | <GreaterThanEquals> | <LessThanEquals>
2047 | <StringEquals> | <StringNotEquals> | <NotEqulas> | <LogicalAnd> | <LogicalOr>
2048 | <EmbedBlock>
2049  
2050 <objrule: PT::ElsIf> <[ElsIfChain]>+
2051 <objrule: PT::ElsIfChain> <TokenElsIf> <LParen> <BoolExpression> <RParen> <CodeBlock>
2052 <objrule: PT::Else> <TokenElse> <CodeBlock>
2053  
2054 <objrule: PT::Statement> <FunctionReferenceCall> | <VariableDeclaration> | <Regex> | <MakeGroup> | <FunctionCall>
2055 | <ClassFunctionCall> | <ObjectCall> | <Assignment> | <Return> | <Last> | <Next>
2056  
2057 <objrule: PT::Regex> <TokenMakeRegex> <LParen> <RegexVariable> <Comma> <Regexp> <Comma> <Modifiers> <RParen> <SemiColon>
2058 <objrule: PT::RegexVariable> <VariableName>
2059 <objrule: PT::Regexp> <BackSlash> <Pre> <BackSlash>
2060 <objrule: PT::Pre> (?<=\/)\s*.*?\s*(?=\/\,)
2061 <objrule: PT::Modifiers> <LParen> <RegexModifiers> <RParen>
2062 <objtoken: PT::RegexModifiers> [nmasdilxpu]+
2063  
2064 <objrule: PT::ClassFunctionCall> <TokenClass> <Dot> <FunctionName> <LParen> <Parameters>? <RParen> <SemiColon>
2065  
2066 <objrule: PT::ObjectCall> <ObjectFunctionCall> <SemiColon>
2067 <objrule: PT::VariableDeclaration> <ArrayDeclaration> | <HashDeclaration> | <ScalarDeclaration>
2068  
2069 <objrule: PT::GroupDeclaration> <TokenGroup> <GroupName> <GroupBlock> <SemiColon>
2070 <objtoken: PT::GroupName> <VariableName>
2071 <objrule: PT::GroupBlock> <LessThan> <GroupElements> <GreaterThan>
2072 <objrule: PT::GroupElements> <[GroupElement]>+ % <Comma>
2073 <objrule: PT::GroupElement> [A-Za-z]+
2074  
2075 <objrule: PT::MakeGroup> <TokenMakeGroup> <LParen> <GroupName> <Comma> <GroupNameObject> <RParen> <SemiColon>
2076 <objrule: PT::GroupNameObject> <VariableName>
2077 <objrule: PT::GroupReference> <TokenGroupReference> <GroupName>
2078  
2079 <objrule: PT::GroupAssignment> <GroupAccess> <Equal> <RHS> <SemiColon>
2080 <objrule: PT::GroupAccess> <GroupName> <[GroupAccessElement]>+
2081 <objrule: PT::GroupAccessElement> <LessThan> <GroupElement> <GreaterThan>
2082  
2083 <objrule: PT::ScalarDeclaration> <Var> <VariableName> <Equal> <Value> <SemiColon>
2084 <objtoken: PT::Var> var
2085 <objtoken: PT::VariableName> [a-zA-Z_]+?
2086 <objrule: PT::Value> <RHS>
2087 <objtoken: PT::Number> [0-9]+
2088 <objtoken: PT::RealNumber> [-]?[0-9]+\.?[0-9]+|[0-9]+
2089 <objrule: PT::String> <LQuote> <StringValue> <RQuote>
2090 <objrule: PT::LQuote> <Quote>
2091 <objrule: PT::RQuote> <Quote>
2092 <objtoken: PT::StringValue> (?<=")\s*.*?\s*(?=")
2093  
2094 <objrule: PT::ArrayDeclaration> <Var> <VariableName> <Equal> <ArrayList> <SemiColon>
2095 <objrule: PT::ArrayList> <LBracket> <ListElements> <RBracket>
2096 <objrule: PT::ListElements> .{0} | <[ListElement]>+ % <Comma>
2097  
2098 <objrule: PT::ListElement> <RealNumber> | <String> | <ClassFunctionReturn> | <FunctionReturn>
2099 | <ArrayElement> | <HashElement> | <ArrayList> | <HashRef>
2100 | <VariableName> | <EmbedBlock>
2101  
2102 <objrule: PT::HashDeclaration> <Var> <VariableName> <Equal> <HashRef> <SemiColon>
2103 <objrule: PT::HashRef> <LBrace> <KeyValuePairs> <RBrace>
2104 <objrule: PT::KeyValuePairs> .{0} | <[KeyValue]>+ % <Comma>
2105 <objrule: PT::KeyValue> <PairKey> <Colon> <PairValue>
2106  
2107 <objrule: PT::PairKey> <Number> | <String> | <ClassFunctionReturn> | <FunctionReturn>
2108 | <VariableName> | <EmbedBlock>
2109  
2110 <objrule: PT::PairValue> <RealNumber> | <String> | <ClassFunctionReturn> | <FunctionReturn>
2111 | <ArrayElement> | <HashElement> | <ArrayList> | <HashRef>
2112 | <VariableName> | <EmbedBlock>
2113  
2114 <objrule: PT::FunctionCall> <FunctionName> <LParen> <Parameters>? <RParen> <SemiColon>
2115 <objrule: PT::Parameters> <[Param]>+ % <Comma>
2116 <objrule: PT::Param> <RealNumber> | <String> | <VariableName> | <ArrayElement> | <HashElement>
2117 | <HashRef> | <FunctionReturn> | <ClassFunctionReturn> | <GroupAccess> | <EmbedBlock>
2118 | <FunctionReference> | <GroupAccess> | <ClassFunctionReturn> | <Calc> | <ParamChars> | <ObjectFunctionCall>
2119  
2120 <objtoken: PT::ParamChars> [A-Za-z]+
2121  
2122 <objrule: PT::Assignment> <ScalarAssignment> | <ArrayAssignment> | <HashAssignment> | <AccessorAssignment> | <GroupAssignment>
2123  
2124 <objrule: PT::ScalarAssignment> <ScalarVariable> <Equal> <RHS> <SemiColon>
2125 <objtoken: PT::ScalarVariable> [a-zA-Z]+
2126  
2127 <objrule: PT::RHS> <RealNumber> | <FunctionReference> | <FunctionReturn> | <ArrayElement> | <HashElement>
2128 | <ScalarVariable> | <Calc> | <ArrayList> | <HashRef> | <ClassAccessor>
2129 | <GroupElement> | <GroupReference> | <MakeGroup> | <GroupAccess> | <ClassFunctionReturn>
2130 | <String> | <STDIN> | <RegexMatchVariables> | <ObjectFunctionCall> | <EmbedBlock>
2131  
2132 <objrule: PT::RegexMatchVariables> <RegexMatchSymbol> <MatchVariable>
2133 <objrule: PT::MatchVariable> <Number> | <MatchParts>
2134 <objtoken: PT::MatchParts> PREMATCH|MATCH|POSTMATCH
2135  
2136 <objrule: PT::FunctionReference> <TokenReference> <TokenClass> <Dot> <FunctionName> <LParen> <RParen>
2137 <objrule: PT::FunctionReferenceCall> <TokenReferenceCall> <FunctionName> <LParen> <Parameters>? <RParen> <SemiColon>
2138  
2139 <objrule: PT::FunctionReturn> <FunctionName> <LParen> <Parameters>? <RParen>
2140  
2141 <objrule: PT::ArrayElement> <ArrayName> <[ArrayAccess]>+
2142 <objrule: PT::ArrayAccess> <LBracket> <ArrayKey> <RBracket>
2143 <objrule: PT::ArrayKey> <Number> | <ScalarVariable> | <ArrayElement>
2144 | <HashElement> | <FunctionReturn> | <ClassFunctionReturn>
2145 <objrule: PT::ArrayName> [a-zA-Z]+?
2146  
2147 <objrule: PT::HashElement> <HashName> <[HashAccess]>+
2148 <objrule: PT::HashAccess> <LBrace> <HashKey> <RBrace>
2149 <objtoken: PT::HashName> [a-zA-Z]+?
2150 <objrule: PT::HashKey> <String> | <Number> | <ScalarVariable> | <ArrayElement>
2151 | <HashElement> | <FunctionReturn> | <ClassFunctionReturn>
2152  
2153 <objrule: PT::STDIN> <LessThan> <TokenSTDIN> <GreaterThan>
2154  
2155 <objtoken: PT::HashKeyStringValue> [a-zA-Z]+?
2156 <objrule: PT::AccessorAssignment> <TokenClass> <Dot> <HashKeyStringValue> <Equal> <RHS> <SemiColon>
2157 <objrule: PT::ClassAccessor> <TokenClass> <Dot> <HashKeyStringValue>
2158 <objrule: PT::ClassFunctionReturn> <TokenClass> <Dot> <FunctionName> <LParen> <Parameters>? <RParen>
2159  
2160 <objrule: PT::ArrayAssignment> <ArrayElement> <Equal> <RHS> <SemiColon>
2161 <objrule: PT::HashAssignment> <HashElement> <Equal> <RHS> <SemiColon>
2162  
2163 <objrule: PT::Calc> <CalcExpression>
2164 <objrule: PT::CalcExpression> <[CalcOperands]>+ % <[CalcOperator]>
2165 <objrule: PT::CalcOperands> <RealNumber> | <ScalarVariable> | <ArrayElement> | <HashElement> | <ClassAccessor>
2166 | <ClassFunctionReturn> | <FunctionReturn> | <EmbedBlock> | <ObjectFunctionCall>
2167  
2168 <objtoken: PT::CalcOperator> <Plus> | <Minus> | <Multiply> | <Divide> | <Modulus> | <Exponent> | <EmbedBlock>
2169  
2170 <objrule: PT::Return> <TokenReturn> <RHS>? <SemiColon>
2171 <objrule: PT::Last> <TokenLast> <SemiColon>
2172 <objrule: PT::Next> <TokenNext> <SemiColon>
2173  
2174 <objrule: PT::ObjectFunctionCall> [!] <Object> <Dot> <FunctionName> <LParen> <Parameters>? <RParen>
2175  
2176 <objtoken: PT::TokenReturn> return
2177 <objtoken: PT::TokenNext> next
2178 <objtoken: PT::TokenLast> last
2179 <objtoken: PT::TokenElse> else
2180 <objtoken: PT::TokenElsIf> elsif
2181 <objtoken: PT::TokenIf> if
2182 <objtoken: PT::TokenFor> for
2183 <objtoken: PT::TokenForeach> forEach
2184 <objtoken: PT::TokenWhile> while
2185 <objtoken: PT::TokenFunction> function
2186 <objtoken: PT::TokenParent> parent
2187 <objtoken: PT::TokenClass> class
2188 <objtoken: PT::TokenEmbedBlock> embed
2189 <objtoken: PT::TokenSTDIN> STDIN
2190 <objtoken: PT::TokenNot> not
2191 <objtoken: PT::TokenArrayEach> arrayEach
2192 <objtoken: PT::TokenHashEach> hashEach
2193 <objtoken: PT::TokenImplement> implement
2194 <objtoken: PT::TokenTry> try
2195 <objtoken: PT::TokenCatch> catch
2196 <objtoken: PT::TokenError> error
2197 <objtoken: PT::TokenMakeRegex> makeRegex
2198 <objtoken: PT::TokenMatchRegex> matchRegex
2199 <objtoken: PT::TokenReference> reference
2200 <objtoken: PT::TokenReferenceCall> referenceCall
2201 <objtoken: PT::TokenGroup> group
2202 <objtoken: PT::TokenMakeGroup> makeGroup
2203 <objtoken: PT::TokenGroupReference> groupReference
2204  
2205 <objtoken: PT::BackSlash> \/
2206 <objtoken: PT::RegexMatchSymbol> \@
2207 <objtoken: PT::EachSymbol> =\>
2208 <objtoken: PT::Ampersand> \&
2209 <objtoken: PT::Asterisk> \*
2210 <objtoken: PT::Modulus> \%
2211 <objtoken: PT::Exponent> \*\*
2212 <objtoken: PT::LogicalAnd> \&\&
2213 <objtoken: PT::LogicalOr> \|\|
2214 <objtoken: PT::NotEqulas> \!=
2215 <objtoken: PT::StringNotEquals> ne
2216 <objtoken: PT::StringEquals> eq
2217 <objtoken: PT::LessThanEquals> \<=
2218 <objtoken: PT::GreaterThanEquals> \>=
2219 <objtoken: PT::GreaterThan> \>
2220 <objtoken: PT::LessThan> \<
2221 <objtoken: PT::Equals> ==
2222 <objtoken: PT::Plus> \+
2223 <objtoken: PT::Minus> \-
2224 <objtoken: PT::Multiply> \*
2225 <objtoken: PT::Divide> \/
2226 <objtoken: PT::Quote> "
2227 <objtoken: PT::SemiColon> ;
2228 <objtoken: PT::Colon> :
2229 <objtoken: PT::Dot> \.
2230 <objtoken: PT::Equal> =
2231 <objtoken: PT::Comma> ,
2232 <objtoken: PT::LParen> \(
2233 <objtoken: PT::RParen> \)
2234 <objtoken: PT::LBrace> \{
2235 <objtoken: PT::LBraceError> \s.
2236 <objtoken: PT::RBrace> \}
2237 <objtoken: PT::RBraceError> \s*.
2238 <objtoken: PT::LBracket> \[
2239 <objtoken: PT::RBracket> \]
2240 }xms;
2241  
2242 0 ▶sub parse {
Subroutine parse: not called CC=2 SCAR=17.9
Pod undocumented
2243 0 my ($class, $program) = @_;
2244 0 ▶ if($program =~ $parser) {
Branch: 1 branch
BranchTrueFalseTotal
if ($program =~ /$parser/) { } 0 0 0
2245 0 my $code = $/{Lang}->X();
2246 0 return $code;
2247 } else {
2248 0 my $notMatch = "print 'Error';";
2249 0 return $notMatch;
2250 }
2251 }
2252  
2253 1 1;
2254  
2255 __END__
↑ Summary