| line |
true |
false |
branch |
|
60
|
0 |
1524 |
unless my $parser = $args{'parser'} |
|
86
|
974 |
550 |
unless exists $self->{'varmap'}{'inst'} |
|
87
|
974 |
550 |
unless exists $self->{'varmap'}{'fun'} |
|
88
|
974 |
550 |
unless exists $self->{'varmap'}{'class'} |
|
89
|
974 |
550 |
unless exists $self->{'varmap'}{'static'} |
|
90
|
1246 |
278 |
unless exists $self->{'varmap'}{'stdout'} |
|
92
|
0 |
0 |
if exists $self->{'with'}{'getenv'} and $self->{'toplevel'} |
|
102
|
378 |
423 |
unless exists $args{'globals'} |
|
103
|
106 |
695 |
unless exists $args{'varmap'} |
|
104
|
731 |
70 |
unless exists $args{'parser'} |
|
120
|
0 |
801 |
exists $ctx->{'log'} ? : |
|
|
65 |
736 |
exists $ctx->{'class_scope'} ? : |
|
134
|
64 |
108 |
$ctx->{'infunction'} ? : |
|
156
|
232 |
10 |
if (exists $ctx->{'globals'}{'fun'}) |
|
157
|
232 |
0 |
if (exists $ctx->{'varmap'}{'fun'}) { } |
|
163
|
229 |
13 |
if (exists $ctx->{'globals'}{'class'}) |
|
164
|
229 |
0 |
if (exists $ctx->{'varmap'}{'class'}) { } |
|
172
|
8 |
234 |
if (exists $ctx->{'varmap'}{'global'}) |
|
182
|
0 |
272 |
unless my $varmap = $args{'varmap'} |
|
189
|
1 |
271 |
if (exists $ctx->{'varmap'}{'$this'}) |
|
192
|
272 |
0 |
if (exists $ctx->{'varmap'}{'inst'}) |
|
195
|
272 |
0 |
if (exists $ctx->{'varmap'}{'fun'}) |
|
198
|
272 |
0 |
if (exists $ctx->{'varmap'}{'class'}) |
|
201
|
272 |
0 |
if (exists $ctx->{'varmap'}{'static'}) |
|
237
|
0 |
0 |
if (exists $ctx->{'with'}{'getenv'} and scalar @$args == 1) |
|
239
|
0 |
0 |
if (defined $s) |
|
243
|
0 |
0 |
if (exists $ctx->{'globals'}{'$_ENV'}) |
|
246
|
0 |
0 |
if ($s ne uc $s) |
|
250
|
0 |
0 |
if (defined $arrval) |
|
270
|
1 |
0 |
if (scalar @$args >= 1) { } |
|
275
|
1 |
0 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'} and defined $name) |
|
276
|
1 |
0 |
unless ($ctx->{'infunction'}) |
|
277
|
0 |
1 |
if $ctx->{'log'} |
|
280
|
1 |
0 |
if (defined $fun) { } |
|
299
|
0 |
0 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'}) |
|
300
|
0 |
0 |
unless ($ctx->{'infunction'}) |
|
301
|
0 |
0 |
if $ctx->{'log'} |
|
315
|
1 |
0 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'}) |
|
316
|
1 |
0 |
if (exists $ctx->{'globals'}{'stdout'}{'handler'}) { } |
|
317
|
1 |
0 |
unless ($ctx->{'infunction'}) |
|
323
|
0 |
1 |
if $ctx->{'log'} |
|
326
|
1 |
0 |
if (is_strval($s) and $handler ne '#null') { } |
|
330
|
1 |
0 |
if (defined $k) |
|
337
|
1 |
0 |
if (@r) |
|
345
|
0 |
0 |
unless ($ctx->{'infunction'}) |
|
357
|
0 |
0 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'}) |
|
358
|
0 |
0 |
if (exists $ctx->{'globals'}{'stdout'}{'handler'}) { } |
|
359
|
0 |
0 |
unless ($ctx->{'infunction'}) |
|
365
|
0 |
0 |
unless ($ctx->{'infunction'}) |
|
378
|
10 |
1526 |
if ($k =~ /^#stmt\d+$/ and $parser->{'strmap'}{$k}[0] eq 'namespace') { } |
|
|
175 |
1351 |
elsif ($k =~ /^#fun\d+$/) { } |
|
|
53 |
1298 |
elsif ($k =~ /^#class\d+$/) { } |
|
383
|
164 |
11 |
if (defined $f) |
|
391
|
45 |
44 |
if ($a =~ /^#fun\d+$/) |
|
393
|
45 |
0 |
if (defined $f) |
|
394
|
45 |
0 |
defined $c ? : |
|
400
|
53 |
0 |
if (defined $c) |
|
414
|
457 |
327 |
if (is_block($stmt)) |
|
418
|
10 |
1080 |
if ($k =~ /^#stmt\d+$/ and $parser->{'strmap'}{$k}[0] eq 'namespace') { } |
|
|
184 |
896 |
elsif ($k =~ /^#(fun|class)\d+$/) { } |
|
432
|
1 |
456 |
if (scalar @block == 1) |
|
446
|
784 |
8 |
if (defined $s) |
|
447
|
0 |
784 |
if $ctx->{'log'} |
|
449
|
722 |
62 |
if $ctx->{'toplevel'} |
|
454
|
0 |
784 |
if (defined $quote) |
|
461
|
0 |
784 |
if $ctx->{'log'} |
|
467
|
0 |
784 |
if ($parser->{'debug'}) |
|
469
|
0 |
0 |
if $parser->{'debug'} |
|
480
|
784 |
0 |
if (defined $arg) { } |
|
|
0 |
0 |
elsif (is_null($arg)) { } |
|
489
|
456 |
328 |
if (is_block($out)) { } |
|
499
|
0 |
784 |
if $ctx->{'log'} |
|
500
|
456 |
328 |
is_block($out) ? : |
|
503
|
0 |
784 |
if $ctx->{'log'} |
|
511
|
722 |
0 |
if ($ctx->{'toplevel'} and exists $ctx->{'varmap'}{'stdout'}) |
|
512
|
1 |
721 |
if (exists $ctx->{'varmap'}{'stdout'}{'handler'}) |
|
527
|
722 |
0 |
if ($ctx->{'toplevel'} and exists $ctx->{'varmap'}{'stdout'}) |
|
528
|
96 |
626 |
if (@{$ctx->{'varmap'}{'stdout'}{'buf'};}) |
|
534
|
1 |
96 |
if (defined $k) { } |
|
540
|
96 |
0 |
unless (exists $ctx->{'skip'}{'stdout'}) |
|
551
|
519 |
265 |
if (is_block($stmt)) |
|
553
|
12 |
507 |
if ($type ne "flat") |
|
556
|
12 |
0 |
if (scalar @seq > 1) { } |
|
|
0 |
0 |
elsif (scalar @seq > 0) { } |
|
564
|
104 |
680 |
if exists $ctx->{'varmap'}{'stdout'} and scalar @{$ctx->{'varmap'}{'stdout'}{'buf'};} |
|
565
|
0 |
0 |
defined $outlist ? : |
|
|
0 |
784 |
if $ctx->{'log'} |
|
568
|
0 |
0 |
if $ctx->{'log'} |
|
579
|
17 |
842 |
if ($s =~ /^#elem\d+$/) |
|
581
|
17 |
0 |
if (defined $v) |
|
582
|
4 |
13 |
unless (is_variable($v)) |
|
586
|
13 |
0 |
if (defined $i) |
|
587
|
2 |
11 |
unless (is_strval($i)) |
|
601
|
0 |
20 |
if ($s =~ /^#call\d+$/) |
|
603
|
0 |
0 |
if ($f =~ /^#fun\d+$/) |
|
605
|
0 |
0 |
unless (defined $fn) |
|
619
|
7 |
4 |
if $ctx->is_superglobal($var) |
|
620
|
0 |
4 |
if $ctx->is_global_var($var) |
|
633
|
6 |
188 |
if $ctx->is_superglobal($var) |
|
636
|
7 |
181 |
if (not defined $val) { } |
|
|
14 |
167 |
elsif ($val eq '#unresolved') { } |
|
651
|
0 |
0 |
if $ctx->is_superglobal($var) |
|
652
|
0 |
0 |
if $ctx->is_global_var($var) |
|
655
|
0 |
0 |
if (not defined $val) { } |
|
|
0 |
0 |
elsif ($val eq '#unresolved') { } |
|
672
|
99 |
7 |
if (is_strval($s) and not is_const($s)) |
|
675
|
3 |
26 |
unless is_strval($seq->[$i]) and not is_const($seq->[$i]) |
|
677
|
17 |
82 |
if ($i > 0) { } |
|
|
17 |
65 |
elsif ($s =~ /^#(const|num)\d+$/) { } |
|
|
1 |
64 |
elsif (is_null($s)) { } |
|
699
|
12 |
116 |
if (scalar @$seq == 1) |
|
710
|
10 |
0 |
if (is_block($s)) { } |
|
712
|
0 |
10 |
if ($type ne "std") |
|
729
|
4 |
0 |
unless (_anon_func_call($parser, $s)) |
|
742
|
0 |
0 |
if (is_block($s)) |
|
744
|
0 |
0 |
if (scalar @$a > 0) |
|
756
|
318 |
2445 |
if (is_block($s)) |
|
758
|
300 |
18 |
if (scalar @$a > 0) |
|
762
|
767 |
1696 |
if ($s =~ /^#stmt\d+$/) |
|
764
|
391 |
376 |
if ($cmd =~ /^$pattern$/) |
|
776
|
0 |
0 |
if (is_block($s)) |
|
781
|
0 |
0 |
if (scalar @$sublist > 0) |
|
787
|
0 |
0 |
if ($s =~ /^#fun\d+$/) |
|
798
|
0 |
0 |
if (is_block($s)) |
|
803
|
0 |
0 |
if (scalar @$sublist > 0) |
|
809
|
0 |
0 |
if ($s =~ /^#call\d+$/) |
|
812
|
0 |
0 |
unless (is_strval($p) or is_array($p)) |
|
824
|
40 |
64 |
if ($s =~ /^#stmt\d+$/) |
|
827
|
40 |
0 |
if ($cmd eq "echo") |
|
831
|
0 |
40 |
unless is_strval($p) |
|
845
|
7 |
95 |
if $info->{'calls'}{$call} eq "return" |
|
848
|
95 |
0 |
unless ($name =~ /^(ob_start|exit|die|__halt_compiler)$/i) |
|
849
|
95 |
0 |
unless ($name =~ /^(error_reporting)$/i) |
|
850
|
95 |
0 |
if ($name =~ /^$pattern$/) |
|
858
|
50 |
1 |
if ($cmd eq 'echo') { } |
|
|
1 |
0 |
elsif ($cmd ne 'global') { } |
|
862
|
0 |
50 |
if (scalar @$arglist > 1 or not is_strval($arglist->[0])) |
|
863
|
0 |
0 |
if ($cmd =~ /^$pattern$/) |
|
868
|
1 |
0 |
if ($cmd =~ /^$pattern$/) |
|
893
|
32 |
169 |
if (defined $fun) { } |
|
|
40 |
129 |
elsif (my $f = PHP::Decode::Func::get_php_func($call)) { } |
|
898
|
32 |
0 |
unless (exists $info->{'resolved'}{$call}) |
|
907
|
2 |
38 |
if (PHP::Decode::Func::func_may_call_callbacks($call)) |
|
909
|
0 |
2 |
if ($call eq "array_filter") |
|
911
|
0 |
0 |
if (scalar @list == 1 and $list[0] eq 1) |
|
913
|
0 |
0 |
if $ctx->{'log'} |
|
917
|
2 |
0 |
unless ($skip) |
|
927
|
0 |
273 |
if ($var =~ /^#elem\d+$/) { } |
|
|
265 |
8 |
elsif (is_variable($var)) { } |
|
|
7 |
1 |
elsif ($var =~ /^#obj\d+$/) { } |
|
932
|
0 |
0 |
if (defined $g) { } |
|
|
0 |
0 |
elsif ($ctx->is_superglobal($v)) { } |
|
|
0 |
0 |
elsif (is_variable($v)) { } |
|
938
|
0 |
0 |
if (defined $g) { } |
|
949
|
26 |
239 |
if (defined $g) |
|
953
|
2 |
237 |
if ($ctx->is_superglobal($var)) |
|
972
|
0 |
209 |
unless ($s =~ /^#fun\d+$/) |
|
978
|
92 |
117 |
if ($s =~ /^#stmt\d+$/) |
|
980
|
61 |
31 |
if (lc $cmd eq "return") |
|
982
|
7 |
54 |
if ($val =~ /^#call\d+$/) |
|
986
|
5 |
1 |
if (is_symbol($name) and lc $name ne "eval" and scalar @$arglist == scalar @$a) |
|
990
|
1 |
3 |
if ($k ne $a->[$i]) |
|
995
|
4 |
1 |
if ($arg_match) |
|
1011
|
54 |
949 |
if ($rhs =~ /^#expr\d+$/) |
|
1014
|
0 |
54 |
if ($op eq "=" and defined $v2) |
|
1027
|
73 |
876 |
if (my $c = _skipped_call($parser, $rhs, '(.*)', $info)) { } |
|
|
7 |
869 |
elsif (not is_variable($rhs) || is_flat_elem($rhs, $parser) and $ctx->unresolvable_var($info)) { } |
|
|
17 |
852 |
elsif (is_variable($rhs)) { } |
|
1042
|
15 |
2 |
if (defined $val and $val eq "#unresolved") |
|
1054
|
50 |
1188 |
if ($stmt =~ /^#expr\d+$/) |
|
1066
|
1120 |
1225 |
if ($stmt =~ /^#expr\d+$/) |
|
1069
|
1070 |
50 |
if ($op eq "=" and defined $v2) |
|
1080
|
50 |
110 |
if ($var =~ /^#elem\d+$/) |
|
1084
|
50 |
0 |
if (defined $val and is_array($val)) |
|
1107
|
133 |
27 |
if (defined $v) |
|
1113
|
10 |
157 |
unless (defined $vp) |
|
1114
|
0 |
10 |
if (is_strval($prev) or is_array($prev)) { } |
|
|
1 |
9 |
elsif (not _get_echo_arglist($parser, $prev)) { } |
|
1124
|
1 |
156 |
unless (is_strval($lhsp) or is_array($lhsp)) |
|
1130
|
53 |
103 |
if (is_variable($v) and $v eq $vp) |
|
1131
|
0 |
53 |
if $ctx->{'log'} |
|
1141
|
38 |
65 |
if (defined $va) |
|
1142
|
21 |
17 |
if ($va eq $vp) |
|
1144
|
0 |
21 |
if $ctx->{'log'} |
|
1156
|
12 |
45 |
if (defined $va) |
|
1163
|
5 |
7 |
if ($size > 1) |
|
1164
|
0 |
5 |
if $ctx->{'log'} |
|
1167
|
0 |
12 |
if $ctx->{'log'} |
|
1178
|
21 |
51 |
if (defined $args) |
|
1183
|
12 |
10 |
unless (defined $prev_args) |
|
1187
|
10 |
0 |
if ($all_str and $prev_all_str) { } |
|
1194
|
0 |
10 |
if $ctx->{'log'} |
|
1210
|
98 |
138 |
if ($ctx->{'tainted'}) { } |
|
1215
|
0 |
236 |
if (exists $ctx->{'with'}{'invalidate_tainted_vars'}) |
|
1217
|
0 |
0 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1222
|
0 |
0 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1235
|
6 |
0 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1236
|
5 |
1 |
if (not exists $ctx->{'globals'}{$k} or $ctx->{'globals'}{$k} ne "#unresolved") |
|
1237
|
0 |
5 |
if $ctx->{'log'} |
|
1249
|
82 |
5 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1250
|
45 |
37 |
if (not exists $ctx->{'varmap'}{$k} or $ctx->{'varmap'}{$k} ne "#unresolved") |
|
1251
|
0 |
45 |
if $ctx->{'log'} |
|
1263
|
15 |
0 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1264
|
12 |
3 |
unless (exists $ctx->{'globals'}{$k}) |
|
1265
|
0 |
12 |
if $ctx->{'log'} |
|
1277
|
114 |
31 |
if (is_variable($k) and not $ctx->is_superglobal($k)) |
|
1278
|
63 |
51 |
unless (exists $ctx->{'varmap'}{$k}) |
|
1279
|
1 |
62 |
if (exists $ctx->{'varmap'}{'global'}{$k}) { } |
|
1280
|
1 |
0 |
unless (exists $ctx->{'globals'}{$k}) |
|
1281
|
0 |
1 |
if $ctx->{'log'} |
|
1285
|
0 |
62 |
if $ctx->{'log'} |
|
1299
|
12 |
90 |
if (keys %{$$info{"globals"};}) |
|
1303
|
96 |
6 |
if (keys %{$$info{"vars"};}) |
|
1305
|
96 |
0 |
if (@vars) |
|
1318
|
3 |
28 |
if (keys %{$$info{"global_assigns"};}) |
|
1322
|
28 |
3 |
if (keys %{$$info{"local_assigns"};}) |
|
1326
|
18 |
13 |
if (keys %{$$info{"unresolved"};}) |
|
1331
|
2 |
16 |
if (keys %{$$info{"globals"};}) |
|
1335
|
17 |
1 |
if (keys %{$$info{"vars"};}) |
|
1337
|
17 |
0 |
if (@vars) |
|
1352
|
178 |
875 |
if (is_variable($k) and not $ctx2->is_superglobal($k)) |
|
1353
|
34 |
144 |
if (not exists $ctx->{'globals'}{$k} or $ctx->{'globals'}{$k} ne $ctx2->{'globals'}{$k}) |
|
1354
|
0 |
34 |
if $ctx->{'log'} |
|
1360
|
294 |
1179 |
if (is_variable($k) and not $ctx2->is_superglobal($k)) |
|
1361
|
37 |
257 |
if (not exists $ctx->{'varmap'}{$k} or $ctx->{'varmap'}{$k} ne $ctx2->{'varmap'}{$k}) |
|
1362
|
0 |
37 |
if $ctx->{'log'} |
|
1381
|
10 |
10 |
if (defined $g) |
|
1384
|
0 |
10 |
if (exists $ctx->{'varmap'}{'global'}{$var}) |
|
1387
|
0 |
10 |
unless ($ctx->{'infunction'}) |
|
1398
|
46 |
1810 |
if (defined $inst) |
|
1407
|
0 |
0 |
if (defined $inst) |
|
1419
|
9 |
782 |
if (not $ctx->{'infunction'} and $ctx->{'class_scope'}) |
|
1421
|
9 |
0 |
if (not defined $inst or $inst ne "GLOBALS") |
|
1427
|
55 |
1105 |
if defined $inst |
|
1429
|
14 |
1146 |
if ($ctx->is_superglobal($var)) |
|
1432
|
34 |
1126 |
if (defined $global) { } |
|
|
10 |
1116 |
elsif (exists $ctx->{'varmap'}{'global'}{$var}) { } |
|
|
6 |
1110 |
elsif (exists $ctx->{'varmap'}{'ref'}{$var}) { } |
|
|
4 |
1106 |
elsif (exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$var}) { } |
|
|
27 |
1079 |
elsif (defined $inst and exists $ctx->{'varmap'}{'inst'}{$inst}) { } |
|
1433
|
34 |
0 |
if (exists $ctx->{'globals'}) |
|
1438
|
10 |
0 |
if (exists $ctx->{'globals'}) |
|
1447
|
3 |
1 |
if ($ctx->{'infunction'} and $ctx->{'incall'}) { } |
|
1460
|
1153 |
7 |
if ($wasset) |
|
1461
|
192 |
961 |
if (not $in_block) { } |
|
1462
|
0 |
192 |
if $ctx->{'log'} |
|
1465
|
0 |
961 |
if $ctx->{'log'} |
|
1474
|
3 |
893 |
if ($name =~ /^\\(.*)$/) { } |
|
|
7 |
886 |
elsif ($ctx->{'namespace'}) { } |
|
1492
|
62 |
234 |
if (exists $ctx->{'class_scope'}) { } |
|
1497
|
6 |
290 |
if ($ctx->{'namespace'}) |
|
1500
|
9 |
287 |
if ($ctx->{'infunction'}) { } |
|
1505
|
0 |
296 |
if $ctx->{'log'} |
|
1518
|
196 |
1021 |
if (defined $inst) |
|
1519
|
60 |
112 |
if (exists $ctx->{'varmap'}{'inst'}{$inst} and exists $ctx->{'varmap'}{'inst'}{$inst}{$prop}) |
|
1532
|
30 |
1127 |
if (my $method = $ctx->lookup_method_name($name)) { } |
|
|
59 |
1068 |
elsif (exists $ctx->{'class_scope'}) { } |
|
1536
|
31 |
28 |
if (exists $ctx->{'globals'}{'fun'}{$method}) { } |
|
|
0 |
28 |
elsif (exists $ctx->{'varmap'}{'fun'}{$method}) { } |
|
1542
|
341 |
785 |
if (exists $ctx->{'globals'}{'fun'}{$name}) { } |
|
|
4 |
781 |
elsif (exists $ctx->{'varmap'}{'fun'}{$name}) { } |
|
1555
|
1 |
67 |
if ($ctx->{'namespace'}) |
|
1558
|
2 |
66 |
if ($ctx->{'infunction'}) { } |
|
1563
|
0 |
68 |
if $ctx->{'log'} |
|
1572
|
126 |
10 |
if (exists $ctx->{'globals'}{'class'}{$name}) { } |
|
|
1 |
9 |
elsif (exists $ctx->{'varmap'}{'class'}{$name}) { } |
|
1587
|
127 |
1904 |
if defined $inst |
|
1589
|
273 |
1758 |
if ($ctx->is_superglobal($var)) |
|
1592
|
331 |
1700 |
if (defined $global) { } |
|
|
14 |
1686 |
elsif (exists $ctx->{'varmap'}{'global'}{$var}) { } |
|
|
3 |
1683 |
elsif (exists $ctx->{'varmap'}{'ref'}{$var}) { } |
|
|
13 |
1670 |
elsif (exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$var}) { } |
|
|
45 |
1625 |
elsif (defined $inst and exists $ctx->{'varmap'}{'inst'}{$inst}) { } |
|
|
1387 |
238 |
elsif (exists $ctx->{'varmap'}{$var}) { } |
|
1593
|
331 |
0 |
if (exists $ctx->{'globals'}) |
|
1594
|
43 |
288 |
if (exists $ctx->{'globals'}{$global}) |
|
1598
|
31 |
257 |
unless ($ctx->is_superglobal($var)) |
|
1599
|
31 |
0 |
if ($ctx->{'incall'} or not exists $ctx->{'skip'}{'null'}) |
|
1600
|
5 |
26 |
unless ($ctx->{'tainted'}) |
|
1601
|
5 |
0 |
unless $quiet |
|
1606
|
281 |
2 |
unless $quiet |
|
1609
|
14 |
0 |
if (exists $ctx->{'globals'}) |
|
1610
|
9 |
5 |
if (exists $ctx->{'globals'}{$var}) |
|
1614
|
5 |
0 |
unless $quiet |
|
1620
|
9 |
4 |
if ($ctx->{'infunction'} and $ctx->{'incall'}) |
|
1622
|
1 |
8 |
unless (defined $val) |
|
1627
|
4 |
0 |
unless $quiet |
|
1629
|
40 |
5 |
if (exists $ctx->{'varmap'}{'inst'}{$inst}{$instvar}) { } |
|
|
0 |
5 |
elsif (exists $ctx->{'class_scope'} and $ctx->{'varmap'}{'inst'}{$ctx->{'class_scope'}}{$instvar}) { } |
|
1631
|
5 |
35 |
unless (defined $val) |
|
1636
|
0 |
0 |
if $ctx->{'log'} |
|
1638
|
0 |
0 |
unless (defined $val) |
|
1643
|
5 |
0 |
if ($ctx->{'incall'} or not exists $ctx->{'skip'}{'null'}) |
|
1644
|
3 |
2 |
unless ($ctx->{'tainted'}) |
|
1645
|
3 |
0 |
unless $quiet |
|
1649
|
2 |
0 |
unless $quiet |
|
1661
|
238 |
0 |
if ($ctx->{'incall'} or not exists $ctx->{'skip'}{'null'}) |
|
1662
|
149 |
89 |
unless ($ctx->{'tainted'}) |
|
1663
|
147 |
2 |
unless $quiet |
|
1667
|
82 |
7 |
unless $quiet |
|
1678
|
202 |
5 |
unless exists $info->{'remaining_locals'} |
|
1679
|
202 |
5 |
unless exists $info->{'remaining_statics'} |
|
1684
|
111 |
734 |
if ($s =~ /^#expr\d+$/) { } |
|
|
4 |
730 |
elsif ($s =~ /^#obj\d+$/) { } |
|
|
180 |
550 |
elsif ($s =~ /^#stmt\d+$/) { } |
|
|
57 |
493 |
elsif (is_variable($s)) { } |
|
1687
|
97 |
14 |
if ($op eq '=' and is_variable($v1)) { } |
|
|
3 |
18 |
elsif ($op eq '=' and $v1 =~ /^#elem\d+$/) { } |
|
1693
|
0 |
97 |
if ($ctx->is_superglobal($v1)) { } |
|
|
3 |
94 |
elsif (exists $ctx->{'varmap'}{'ref'}{$v1}) { } |
|
|
4 |
90 |
elsif (exists $ctx->{'varmap'}{'global'}{$v1}) { } |
|
|
6 |
84 |
elsif (defined $inst and $inst eq 'GLOBALS') { } |
|
|
3 |
81 |
elsif ($ctx->{'infunction'} and exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$v1}) { } |
|
|
12 |
69 |
elsif (defined $inst and exists $ctx->{'class_scope'} and lc $inst eq $ctx->{'class_scope'}) { } |
|
|
69 |
0 |
elsif (exists $info->{'local_assigns'}{$v1}) { } |
|
1694
|
0 |
0 |
if $ctx->{'log'} |
|
1696
|
0 |
3 |
if $ctx->{'log'} |
|
1701
|
0 |
4 |
if $ctx->{'log'} |
|
1706
|
0 |
6 |
if $ctx->{'log'} |
|
1708
|
0 |
3 |
if $ctx->{'log'} |
|
1711
|
0 |
12 |
if $ctx->{'log'} |
|
1715
|
3 |
66 |
if (exists $info->{'noassigns'}{$v1}) { } |
|
|
13 |
53 |
elsif (is_strval($v2)) { } |
|
|
50 |
3 |
elsif (is_array($v2) and PHP::Decode::Op::array_is_const($parser, $v2)) { } |
|
|
2 |
1 |
elsif (is_variable($v2)) { } |
|
1716
|
0 |
3 |
if $ctx->{'log'} |
|
1719
|
0 |
13 |
if $ctx->{'log'} |
|
1723
|
0 |
50 |
if $ctx->{'log'} |
|
1727
|
0 |
2 |
if $ctx->{'log'} |
|
1732
|
0 |
1 |
if $ctx->{'log'} |
|
1736
|
0 |
0 |
if $ctx->{'log'} |
|
1742
|
0 |
3 |
if ($v =~ /^\$GLOBALS$/) { } |
|
|
1 |
2 |
elsif ($ctx->is_superglobal($v)) { } |
|
|
0 |
2 |
elsif (exists $info->{'noassigns'}{$v}) { } |
|
|
2 |
0 |
elsif (is_variable($v)) { } |
|
1743
|
0 |
0 |
if $ctx->{'log'} |
|
1745
|
0 |
1 |
if $ctx->{'log'} |
|
1747
|
0 |
0 |
if $ctx->{'log'} |
|
1750
|
0 |
2 |
if $ctx->{'log'} |
|
1754
|
0 |
0 |
if $ctx->{'log'} |
|
1760
|
4 |
0 |
if (lc $o eq '$this') { } |
|
1765
|
0 |
4 |
if $ctx->{'log'} |
|
1768
|
4 |
176 |
if ($cmd eq 'static') { } |
|
|
4 |
172 |
elsif ($cmd eq 'global') { } |
|
1771
|
2 |
2 |
if ($v =~ /^#expr\d+$/) { } |
|
1772
|
0 |
2 |
if $ctx->{'log'} |
|
1774
|
0 |
2 |
if $ctx->{'log'} |
|
1786
|
10 |
47 |
if ($ctx->is_superglobal($s)) { } |
|
|
3 |
44 |
elsif (exists $ctx->{'varmap'}{'ref'}{$s}) { } |
|
|
0 |
44 |
elsif (exists $ctx->{'varmap'}{'global'}{$s}) { } |
|
|
9 |
35 |
elsif (defined $inst and $inst eq 'GLOBALS') { } |
|
|
3 |
32 |
elsif ($ctx->{'infunction'} and exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$s}) { } |
|
|
16 |
16 |
elsif (defined $inst and exists $ctx->{'class_scope'} and lc $inst eq $ctx->{'class_scope'}) { } |
|
|
12 |
4 |
elsif (exists $info->{'vars'}{$s}) { } |
|
1787
|
0 |
10 |
if $ctx->{'log'} |
|
1789
|
0 |
3 |
if $ctx->{'log'} |
|
1793
|
0 |
0 |
if $ctx->{'log'} |
|
1796
|
0 |
9 |
if $ctx->{'log'} |
|
1798
|
0 |
3 |
if $ctx->{'log'} |
|
1801
|
0 |
16 |
if $ctx->{'log'} |
|
1804
|
0 |
12 |
if (lc $s eq '$this') { } |
|
1805
|
0 |
0 |
if $ctx->{'log'} |
|
1808
|
0 |
12 |
if $ctx->{'log'} |
|
1812
|
0 |
4 |
if $ctx->{'log'} |
|
1819
|
72 |
135 |
if ($out ne $code) |
|
1820
|
0 |
72 |
if $ctx->{'log'} |
|
1834
|
212 |
1606 |
if ($s =~ /^#blk\d+$/) |
|
1841
|
102 |
209 |
if ($i + 1 < scalar @$a) |
|
1844
|
82 |
20 |
if ($k2 =~ /^#stmt\d+$/) |
|
1846
|
74 |
8 |
if ($cmd2 eq "return") |
|
1850
|
67 |
35 |
if (defined $var and $k =~ /^#expr\d+$/) |
|
1852
|
2 |
65 |
if ($op eq "=" and $var eq $v1) |
|
1854
|
0 |
2 |
if $ctx->{'log'} |
|
1863
|
0 |
309 |
if ($v ne $k) { } |
|
1864
|
0 |
0 |
unless ($parser->is_empty_block($v)) |
|
1872
|
2 |
210 |
if ($arg_changed) |
|
1880
|
2 |
510 |
if ($out ne $code) |
|
1881
|
0 |
2 |
if $ctx->{'log'} |
|
1892
|
286 |
11 |
unless (scalar keys %{$$info{"global_assigns"};} > 0) |
|
1899
|
4 |
64 |
if ($s =~ /^#stmt\d+$/) { } |
|
|
16 |
48 |
elsif (is_variable($s)) { } |
|
1901
|
4 |
0 |
if ($cmd eq "global") |
|
1903
|
0 |
4 |
if $ctx->{'log'} |
|
1911
|
0 |
16 |
if (defined $inst and $inst ne 'GLOBALS') { } |
|
|
10 |
6 |
elsif (defined $g) { } |
|
1912
|
0 |
0 |
if ($inst =~ /^#inst\d+$/) { } |
|
1913
|
0 |
0 |
if $ctx->{'log'} |
|
1915
|
0 |
0 |
if $ctx->{'log'} |
|
1918
|
0 |
10 |
if ($cctx->{'infunction'}) { } |
|
1930
|
10 |
1 |
if ($out ne $code) |
|
1931
|
0 |
10 |
if $ctx->{'log'} |
|
1945
|
5 |
11 |
if (is_variable($s)) |
|
1948
|
5 |
0 |
if ($ctx->is_superglobal($s)) { } |
|
|
0 |
0 |
elsif (exists $ctx->{'varmap'}{'ref'}{$s}) { } |
|
|
0 |
0 |
elsif (exists $ctx->{'varmap'}{'global'}{$s}) { } |
|
|
0 |
0 |
elsif (defined $inst and $inst eq 'GLOBALS') { } |
|
|
0 |
0 |
elsif ($ctx->{'infunction'} and exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$s}) { } |
|
|
0 |
0 |
elsif (defined $inst and exists $ctx->{'class_scope'} and lc $inst eq $ctx->{'class_scope'}) { } |
|
|
0 |
0 |
elsif (exists $info->{'vars'}{$s}) { } |
|
1949
|
0 |
5 |
if $ctx->{'log'} |
|
1951
|
0 |
0 |
if $ctx->{'log'} |
|
1953
|
0 |
0 |
if $ctx->{'log'} |
|
1955
|
0 |
0 |
if $ctx->{'log'} |
|
1957
|
0 |
0 |
if $ctx->{'log'} |
|
1959
|
0 |
0 |
if $ctx->{'log'} |
|
1961
|
0 |
0 |
if $ctx->{'log'} |
|
1969
|
0 |
4 |
if ($out ne $code) |
|
1970
|
0 |
0 |
if $ctx->{'log'} |
|
1984
|
129 |
13 |
if ($s =~ /^#stmt\d+$/) |
|
1986
|
127 |
2 |
if ($cmd =~ /^$pattern$/) |
|
1993
|
127 |
0 |
if ($changed) |
|
2009
|
4 |
313 |
unless $allow |
|
2011
|
38 |
275 |
if ($s =~ /^#stmt\d+$/) { } |
|
|
165 |
110 |
elsif ($s =~ /^#blk\d+$/) { } |
|
|
14 |
96 |
elsif ($s =~ /^#expr\d+$/) { } |
|
|
6 |
90 |
elsif ($s =~ /^#elem\d+$/) { } |
|
|
13 |
77 |
elsif ($s =~ /^#call\d+$/) { } |
|
|
5 |
72 |
elsif ($s =~ /^#fun\d+$/) { } |
|
|
0 |
72 |
elsif ($s =~ /^#class\d+$/) { } |
|
|
53 |
19 |
elsif (is_strval($s)) { } |
|
|
0 |
19 |
elsif (is_array($s)) { } |
|
|
19 |
0 |
elsif (is_variable($s)) { } |
|
2013
|
33 |
5 |
if ($cmd eq 'echo') { } |
|
|
0 |
5 |
elsif ($cmd eq 'print') { } |
|
|
4 |
1 |
elsif ($cmd eq 'global') { } |
|
|
0 |
1 |
elsif ($cmd eq 'return') { } |
|
2016
|
0 |
33 |
unless ($ctx->can_inline($a)) |
|
2024
|
0 |
0 |
if ($ctx->can_inline($arg)) |
|
2031
|
0 |
0 |
if $ctx->{'log'} |
|
2040
|
14 |
0 |
if ($op ne "\$") |
|
2041
|
14 |
0 |
if (defined $v1) |
|
2042
|
1 |
13 |
unless ($ctx->can_inline($v1)) |
|
2046
|
13 |
1 |
if ($allow and defined $v2) |
|
2047
|
0 |
13 |
unless ($ctx->can_inline($v2)) |
|
2056
|
0 |
6 |
unless ($ctx->can_inline($v)) |
|
2059
|
6 |
0 |
if ($allow and defined $i) |
|
2060
|
0 |
6 |
unless ($ctx->can_inline($i)) |
|
2068
|
0 |
0 |
if (defined $inst or is_symbol($name) or is_strval($name) or $name =~ /^#fun\d+$/) |
|
2069
|
13 |
0 |
unless ($name =~ /^(eval|create_function)$/i) |
|
2073
|
0 |
4 |
unless ($ctx->can_inline($a)) |
|
2078
|
13 |
0 |
if ($can) |
|
2079
|
0 |
13 |
if $ctx->{'log'} |
|
2089
|
0 |
53 |
if $ctx->{'log'} |
|
2092
|
0 |
0 |
if (PHP::Decode::Op::array_is_const($parser, $s)) |
|
2093
|
0 |
0 |
if $ctx->{'log'} |
|
2099
|
7 |
12 |
if ($ctx->is_superglobal($s)) { } |
|
|
0 |
12 |
elsif (defined $inst and $inst ne 'GLOBALS') { } |
|
|
10 |
4 |
elsif (defined $inst and not $inst =~ /^#inst\d+$/) { } |
|
2100
|
0 |
7 |
if $ctx->{'log'} |
|
2103
|
0 |
0 |
if $ctx->{'log'} |
|
2106
|
0 |
10 |
if $ctx->{'log'} |
|
2127
|
0 |
52 |
unless $allow |
|
2129
|
11 |
41 |
if ($s =~ /^#stmt\d+$/) { } |
|
|
11 |
30 |
elsif ($s =~ /^#blk\d+$/) { } |
|
|
5 |
25 |
elsif ($s =~ /^#expr\d+$/) { } |
|
|
0 |
25 |
elsif ($s =~ /^#call\d+$/) { } |
|
|
6 |
19 |
elsif ($s =~ /^#fun\d+$/) { } |
|
|
0 |
19 |
elsif ($s =~ /^#class\d+$/) { } |
|
|
19 |
0 |
elsif (is_strval($s)) { } |
|
2131
|
9 |
2 |
if ($cmd eq 'echo') { } |
|
|
0 |
2 |
elsif ($cmd eq 'print') { } |
|
|
0 |
2 |
elsif ($cmd eq 'return') { } |
|
|
2 |
0 |
elsif ($cmd =~ /^(if|while|do|for|foreach|switch)$/) { } |
|
2136
|
0 |
0 |
if $ctx->{'log'} |
|
2146
|
5 |
0 |
if ($op eq "=") |
|
2147
|
5 |
0 |
if (is_strval($v2)) |
|
2154
|
0 |
0 |
unless (PHP::Decode::Func::func_may_return_string($_name)) |
|
2176
|
0 |
73 |
if (exists $info->{'returns'} or exists $info->{'calls'}{'eval'} or exists $info->{'calls'}{'create_function'}) |
|
2187
|
3 |
119 |
if ($param->[$i] =~ /^#ref\d+$/) |
|
2190
|
0 |
122 |
if (exists $info->{'vars'}{$param->[$i]}) |
|
2211
|
127 |
2 |
if ($i < scalar @$arglist) |
|
2214
|
1 |
128 |
if ($param->[$i] =~ /^#expr\d+$/) { } |
|
|
3 |
125 |
elsif ($param->[$i] =~ /^#ref\d+$/) { } |
|
2216
|
0 |
1 |
if ($op ne "=") |
|
2222
|
1 |
0 |
unless (defined $val) |
|
2227
|
3 |
0 |
if (is_variable($val)) { } |
|
2232
|
0 |
3 |
if $ctx->{'log'} |
|
2237
|
1 |
124 |
unless (defined $val) |
|
2243
|
128 |
0 |
if (is_variable($var)) |
|
2247
|
0 |
128 |
if (_skipped_call($parser, $val, "(.*)", $info)) |
|
2251
|
0 |
128 |
if ($ctx->contains_local_var($info)) { } |
|
|
0 |
128 |
elsif ($val =~ /^#expr\d+$/ and scalar keys %{$$info{'assigns'};} > 0) { } |
|
|
1 |
127 |
elsif ($val =~ /^#expr\d+$/ and $parser->{'strmap'}{$val}[0] eq '$') { } |
|
|
4 |
123 |
elsif (scalar keys %{$$info{'vars'};} > 0) { } |
|
2263
|
0 |
4 |
if $ctx->{'log'} |
|
2266
|
0 |
123 |
if $ctx->{'log'} |
|
2307
|
2 |
203 |
unless (defined $varmap) |
|
2310
|
0 |
203 |
if $ctx->{'log'} |
|
2320
|
54 |
149 |
if (defined $inst) |
|
2322
|
24 |
30 |
if (defined $method) { } |
|
2325
|
4 |
20 |
if ($prop eq '__construct') { } |
|
|
2 |
18 |
elsif (lc $cmd eq method_name($prop, $prop)) { } |
|
2334
|
10 |
193 |
$cmd =~ /^#fun\d+$/ ? : |
|
2337
|
203 |
0 |
if (defined $res) |
|
2339
|
0 |
203 |
if $ctx->{'log'} |
|
2340
|
200 |
3 |
if (is_block($res)) { } |
|
2347
|
203 |
0 |
if (defined $out) |
|
2352
|
202 |
1 |
if (scalar @$out > 0) { } |
|
2357
|
10 |
192 |
$u ? : |
|
|
19 |
183 |
$f ? : |
|
2360
|
174 |
28 |
if (scalar keys %{$$resinfo{'remaining_locals'};} == 0 and scalar keys %{$$resinfo{'remaining_statics'};} == 0) { } |
|
|
21 |
7 |
elsif (scalar keys %{$$resinfo{'remaining_statics'};} > 0) { } |
|
2361
|
68 |
106 |
if ($res ne $res1) |
|
2372
|
6 |
196 |
if ($is_construct) |
|
2373
|
6 |
0 |
unless (_anon_func_call($parser, $res)) |
|
2376
|
0 |
6 |
if $ctx->{'log'} |
|
2382
|
20 |
176 |
if (defined $u or defined $f) |
|
2383
|
7 |
13 |
if ($ctx2->{'tainted'} > $ctx->{'tainted'}) |
|
2389
|
130 |
66 |
if (_can_return($resinfo)) |
|
2390
|
0 |
130 |
unless (defined $r) |
|
2391
|
0 |
0 |
if ($ctx->{'infunction'} and not $ctx->{'incall'}) |
|
2392
|
0 |
0 |
if $ctx->{'log'} |
|
2395
|
0 |
0 |
if $ctx->{'log'} |
|
2403
|
4 |
126 |
if ($ctx2->contains_local_var($arginfo)) |
|
2404
|
2 |
2 |
if ($ctx->{'infunction'} and not $ctx->{'incall'}) |
|
2405
|
0 |
2 |
if $ctx->{'log'} |
|
2408
|
0 |
2 |
if ($keep_call or $unresolved_param) |
|
2409
|
0 |
0 |
if $ctx->{'log'} |
|
2412
|
0 |
2 |
if $ctx->{'log'} |
|
2420
|
7 |
119 |
if ($keep_call or $unresolved_param) |
|
2422
|
0 |
7 |
if (_can_return($resinfo)) { } |
|
2423
|
0 |
0 |
if $ctx->{'log'} |
|
2426
|
0 |
7 |
if $ctx->{'log'} |
|
2430
|
119 |
0 |
if ($ctx2->can_inline($res1)) |
|
2434
|
0 |
0 |
if $ctx->{'log'} |
|
2442
|
66 |
1 |
if (scalar @$out > 0) |
|
2446
|
0 |
66 |
if $ctx->{'log'} |
|
2448
|
12 |
54 |
if ($keep_call or $unresolved_param) |
|
2451
|
52 |
2 |
if ($ctx2->can_inline($res)) |
|
2468
|
51 |
154 |
if (exists $parser->{'strmap'}{'_CALL'}{$cmd}) { } |
|
2475
|
0 |
205 |
if ($level > 4) { } |
|
2482
|
200 |
5 |
if (defined $ret) |
|
2524
|
55 |
0 |
if ($var =~ /^#expr\d+$/) |
|
2527
|
42 |
0 |
if ($op eq "\$" and not defined $v1 and defined $v2) |
|
2530
|
37 |
5 |
if (defined $val) |
|
2533
|
2 |
3 |
if ($v2 ne $op2) |
|
2547
|
65 |
0 |
if ($var =~ /^#obj\d+$/) |
|
2550
|
0 |
65 |
if ($o =~ /^#inst\d+$/) |
|
2555
|
50 |
15 |
if (defined $basevar and not $has_index) { } |
|
|
0 |
15 |
elsif ($o =~ /^#inst\d+$/) { } |
|
2557
|
29 |
21 |
if ($basestr ne $basevar) |
|
2558
|
0 |
0 |
defined $basestr ? : |
|
|
0 |
29 |
if $ctx->{'log'} |
|
2561
|
0 |
0 |
if $ctx->{'log'} |
|
2564
|
15 |
50 |
unless (defined $basestr) |
|
2566
|
13 |
2 |
if ($inst ne $o) |
|
2567
|
0 |
13 |
if $ctx->{'log'} |
|
2571
|
0 |
0 |
defined $basestr ? : |
|
|
0 |
65 |
if $ctx->{'log'} |
|
2573
|
40 |
25 |
if (defined $basestr and $basestr =~ /^#inst\d+$/) |
|
2579
|
1 |
39 |
if (is_block($m) or is_variable($m)) |
|
2582
|
1 |
39 |
if (is_strval($sym) and not is_null($sym)) |
|
2584
|
0 |
1 |
if $ctx->{'log'} |
|
2598
|
49 |
0 |
if ($var =~ /^#scope\d+$/) |
|
2603
|
0 |
49 |
if ($c =~ /^#class\d+$/) { } |
|
2608
|
1 |
48 |
unless (is_symbol($name)) |
|
2610
|
0 |
1 |
if (is_strval($s) and not is_null($s)) { } |
|
2615
|
0 |
1 |
if $ctx->{'log'} |
|
2617
|
3 |
46 |
if ($name eq 'self') { } |
|
|
0 |
46 |
elsif ($name eq 'parent') { } |
|
2618
|
3 |
0 |
if (exists $ctx->{'class_scope'}) { } |
|
2624
|
0 |
0 |
if (exists $ctx->{'class_scope'}) { } |
|
2634
|
46 |
3 |
if (defined $class) |
|
2637
|
3 |
43 |
unless defined $scopename |
|
2639
|
22 |
24 |
if (is_variable($e)) { } |
|
2641
|
22 |
0 |
if (defined $basevar and is_variable($basevar)) |
|
2642
|
0 |
22 |
if $ctx->{'log'} |
|
2647
|
0 |
24 |
if (is_block($e)) |
|
2650
|
0 |
24 |
if (is_strval($sym) and not is_null($sym)) |
|
2652
|
0 |
0 |
if $ctx->{'log'} |
|
2667
|
11 |
0 |
if ($var =~ /^#ns\d+$/) |
|
2671
|
7 |
4 |
if (not defined $n) { } |
|
2672
|
0 |
7 |
if $ctx->{'log'} |
|
2676
|
4 |
0 |
unless (is_symbol($name)) |
|
2678
|
0 |
4 |
if (is_strval($s) and not is_null($s)) { } |
|
2683
|
0 |
4 |
if $ctx->{'log'} |
|
2685
|
0 |
4 |
if ($name eq 'namespace') { } |
|
2703
|
164 |
0 |
if ($elemlist->[0] =~ /^#elem\d+$/) |
|
2706
|
140 |
24 |
if (defined $i and not $v =~ /^#elem\d+$/) |
|
2711
|
2 |
138 |
if ($v =~ /^#expr\d+$/) { } |
|
|
4 |
134 |
elsif ($v =~ /^#obj\d+$/) { } |
|
2713
|
0 |
2 |
if ($val ne $v and not is_variable($val)) |
|
2718
|
2 |
2 |
if (defined $inst) |
|
2724
|
65 |
75 |
if (defined $val and is_variable($val)) |
|
2727
|
30 |
35 |
if (defined $g) { } |
|
|
21 |
14 |
elsif ($ctx->is_superglobal($val)) { } |
|
2730
|
13 |
17 |
if ($ctx->{'infunction'}) |
|
2734
|
4 |
26 |
if (@$elemlist) { } |
|
2771
|
29 |
94 |
if (is_variable($val)) |
|
2773
|
29 |
0 |
if (not $ctx->is_superglobal($val) or $superglobals_writable) |
|
2778
|
38 |
56 |
if (defined $val and is_strval($val) and $parser->get_strval_or_str($val) eq "") |
|
2782
|
38 |
0 |
unless (exists $ctx->{'skip'}{'treat_empty_str_like_empty_array'}) |
|
2787
|
0 |
123 |
if (defined $val and is_null($val)) |
|
2790
|
119 |
4 |
if (not defined $val or is_array($val)) { } |
|
2791
|
67 |
52 |
if (not defined $val) { } |
|
2796
|
0 |
67 |
if $ctx->{'log'} |
|
2803
|
0 |
52 |
if $ctx->{'log'} |
|
2825
|
22 |
0 |
if (defined $i) |
|
2827
|
1 |
21 |
if is_null($idx) |
|
2829
|
4 |
18 |
if (defined $arrval) |
|
2833
|
21 |
1 |
if (not defined $nextval or is_array($nextval)) |
|
2834
|
18 |
3 |
unless (defined $nextval) |
|
2838
|
0 |
18 |
if $ctx->{'log'} |
|
2841
|
0 |
21 |
if (not defined $idx) { } |
|
|
21 |
0 |
elsif (is_strval($idx)) { } |
|
2843
|
0 |
0 |
if $ctx->{'log'} |
|
2846
|
0 |
21 |
if $ctx->{'log'} |
|
2848
|
0 |
0 |
if $ctx->{'log'} |
|
2851
|
22 |
0 |
if ($elem ne $v or $idx ne $i) |
|
2872
|
0 |
180 |
unless (defined $var) |
|
2876
|
124 |
56 |
if (is_variable($var)) { } |
|
|
0 |
56 |
elsif ($var =~ /^#obj\d+$/) { } |
|
|
0 |
56 |
elsif ($var =~ /^#scope\d+$/) { } |
|
|
16 |
40 |
elsif ($var =~ /^#elem\d+$/) { } |
|
|
40 |
0 |
elsif ($var =~ /^#expr\d+$/) { } |
|
2877
|
0 |
124 |
if (exists $ctx->{'varmap'}{'ref'}{$var}) |
|
2880
|
0 |
0 |
if ($var1 =~ /^\$GLOBALS$/) |
|
2881
|
0 |
0 |
if $ctx->{'log'} |
|
2888
|
0 |
0 |
if (defined $inst) |
|
2890
|
0 |
0 |
if $ctx->{'log'} |
|
2895
|
0 |
0 |
if (defined $scope and is_variable($val)) |
|
2897
|
0 |
0 |
if $ctx->{'log'} |
|
2903
|
0 |
16 |
unless (defined $v) |
|
2907
|
0 |
16 |
if (is_strval($v)) |
|
2911
|
0 |
0 |
if (defined $idxstr) |
|
2912
|
0 |
0 |
if $ctx->{'log'} |
|
2916
|
0 |
16 |
if (is_array($v)) |
|
2920
|
0 |
0 |
if (defined $idxstr) |
|
2921
|
0 |
0 |
if $ctx->{'log'} |
|
2931
|
1 |
15 |
unless ($basevar =~ /^(\#elem\d+)$/) |
|
2932
|
0 |
1 |
if $ctx->{'log'} |
|
2937
|
0 |
0 |
defined $i ? : |
|
|
0 |
0 |
defined $basevar ? : |
|
|
0 |
0 |
defined $baseidx ? : |
|
|
0 |
15 |
if $ctx->{'log'} |
|
2939
|
15 |
0 |
if (defined $basevar) |
|
2940
|
15 |
0 |
if (defined $i) |
|
2947
|
27 |
13 |
if ($val ne $var and not $val =~ /^#expr\d+$/) |
|
2964
|
27 |
599 |
if ($i < scalar @$param and $$param[$i++] =~ /^#ref\d+$/) { } |
|
|
255 |
344 |
elsif (not is_strval($p) or is_const($p)) { } |
|
2972
|
158 |
97 |
if ($v ne $p) |
|
2987
|
2 |
2 |
if ($i < scalar @$param and $$param[$i++] =~ /^#ref\d+$/) |
|
2988
|
2 |
0 |
if (is_variable($p)) |
|
3000
|
0 |
59 |
if (exists $parser->{'strmap'}{'_LOOP'}) { } |
|
3023
|
59 |
0 |
if ($toploop) { } |
|
3037
|
0 |
8049 |
unless (defined $var) |
|
3041
|
1096 |
6953 |
if (is_strval($var) and not is_const($var)) |
|
3044
|
6 |
6947 |
if ($var =~ /^#ref\d+$/) |
|
3047
|
0 |
0 |
$in_block ? : |
|
|
0 |
6947 |
if $ctx->{'log'} |
|
3049
|
1588 |
5359 |
if (is_variable($var)) { } |
|
|
89 |
5270 |
elsif (is_const($var)) { } |
|
|
201 |
5069 |
elsif ($var =~ /^#arr\d+$/) { } |
|
|
22 |
5047 |
elsif ($var =~ /^#obj\d+$/) { } |
|
|
16 |
5031 |
elsif ($var =~ /^#scope\d+$/) { } |
|
|
9 |
5022 |
elsif ($var =~ /^#ns\d+$/) { } |
|
|
363 |
4659 |
elsif ($var =~ /^#elem\d+$/) { } |
|
|
1618 |
3041 |
elsif ($var =~ /^#expr\d+$/) { } |
|
|
733 |
2308 |
elsif ($var =~ /^#call\d+$/) { } |
|
|
1299 |
1009 |
elsif ($var =~ /^#blk\d+$/) { } |
|
|
710 |
299 |
elsif ($var =~ /^#stmt\d+$/) { } |
|
|
242 |
57 |
elsif ($var =~ /^#fun\d+$/) { } |
|
|
56 |
1 |
elsif ($var =~ /^#class\d+$/) { } |
|
3050
|
15 |
1573 |
if (exists $ctx->{'varmap'}{'ref'}{$var}) |
|
3053
|
0 |
15 |
if $ctx->{'log'} |
|
3059
|
266 |
1322 |
if (defined $val and $val eq "#unresolved") |
|
3060
|
0 |
266 |
if $ctx->{'log'} |
|
3070
|
1031 |
557 |
if (defined $val) |
|
3073
|
670 |
361 |
if (is_strval($val)) { } |
|
|
309 |
52 |
elsif (is_array($val)) { } |
|
3075
|
0 |
670 |
if $ctx->{'log'} |
|
3079
|
0 |
309 |
if $ctx->{'log'} |
|
3081
|
0 |
52 |
if $ctx->{'log'} |
|
3100
|
3 |
86 |
if (exists $ctx->{'defines'}{$nv}) { } |
|
|
5 |
81 |
elsif ($v =~ /^__FUNCTION__$/) { } |
|
|
1 |
80 |
elsif ($v =~ /^__CLASS__$/) { } |
|
|
4 |
76 |
elsif ($v =~ /^__METHOD__$/) { } |
|
|
1 |
75 |
elsif ($v =~ /^__NAMESPACE__$/) { } |
|
|
1 |
74 |
elsif ($v =~ /^__DIR__$/) { } |
|
|
0 |
74 |
elsif ($v =~ /^DIRECTORY_SEPARATOR$/) { } |
|
|
0 |
74 |
elsif ($v =~ /^PATH_SEPARATOR$/) { } |
|
|
0 |
74 |
elsif (exists $ctx->{'globals'} and exists $ctx->{'globals'}{$v}) { } |
|
3103
|
0 |
3 |
if $ctx->{'log'} |
|
3106
|
5 |
0 |
if ($ctx->{'infunction'}) { } |
|
3108
|
4 |
1 |
unless defined $prop |
|
3110
|
4 |
1 |
if (defined $fun) |
|
3112
|
1 |
3 |
if ($ctx->{'namespace'}) |
|
3121
|
1 |
0 |
if (exists $ctx->{'class_scope'}) { } |
|
3123
|
1 |
0 |
if (defined $class) |
|
3125
|
0 |
1 |
if ($ctx->{'namespace'}) |
|
3134
|
4 |
0 |
if ($ctx->{'infunction'}) { } |
|
3137
|
4 |
0 |
if (defined $fun) |
|
3141
|
4 |
0 |
if (defined $classname) { } |
|
3148
|
0 |
4 |
if ($ctx->{'namespace'}) |
|
3157
|
1 |
0 |
if ($ctx->{'namespace'}) { } |
|
3171
|
0 |
0 |
if (is_strval($val)) |
|
3174
|
0 |
0 |
if $ctx->{'log'} |
|
3177
|
24 |
50 |
if ($ctx->{'tainted'}) { } |
|
3191
|
145 |
56 |
unless ($ctx->{'incall'}) |
|
3192
|
145 |
0 |
if (exists $ctx->{'simplify'}{'arr'}) |
|
3200
|
191 |
14 |
if (is_int_index($k) || is_strval($k) and !defined($val) || defined $val && is_strval($val)) { } |
|
3206
|
9 |
5 |
unless (is_int_index($k)) |
|
3210
|
14 |
0 |
if (defined $val) { } |
|
3216
|
10 |
4 |
if ($k ne $k2 or $val ne $newmap{$k2}) |
|
3221
|
10 |
135 |
if ($changed) |
|
3226
|
0 |
10 |
if $ctx->{'log'} |
|
3236
|
13 |
9 |
if (defined $inst) |
|
3240
|
11 |
2 |
if (defined $basestr and $basestr ne "#unresolved") |
|
3243
|
0 |
2 |
if ($m ne $prop) |
|
3245
|
0 |
0 |
if $ctx->{'log'} |
|
3254
|
16 |
0 |
if (defined $scope) |
|
3255
|
13 |
3 |
if (is_variable($val)) { } |
|
|
3 |
0 |
elsif (is_symbol($val)) { } |
|
3259
|
2 |
11 |
if (defined $basestr and $basestr ne "#unresolved") |
|
3266
|
3 |
0 |
if (exists $ctx->{'defines'}{$name}) |
|
3268
|
0 |
3 |
if $ctx->{'log'} |
|
3273
|
0 |
0 |
if ($c ne $scope) |
|
3274
|
0 |
0 |
if ($ctx->{'incall'} and $c =~ /^(self|parent)$/) |
|
3279
|
0 |
0 |
if $ctx->{'log'} |
|
3288
|
9 |
0 |
if (defined $ns) |
|
3289
|
0 |
9 |
if ($val =~ /^#class\d+$/) { } |
|
|
0 |
9 |
elsif ($val =~ /^#fun\d+$/) { } |
|
|
4 |
5 |
elsif (is_const($val)) { } |
|
|
0 |
5 |
elsif (is_strval($val)) { } |
|
|
5 |
0 |
elsif (is_symbol($val)) { } |
|
3296
|
4 |
0 |
if (defined $sym and exists $ctx->{'defines'}{$sym}) |
|
3298
|
0 |
4 |
if $ctx->{'log'} |
|
3319
|
18 |
345 |
if (is_null($basestr)) |
|
3322
|
363 |
0 |
if (defined $i) |
|
3323
|
163 |
200 |
if (not is_strval($i) or is_const($i)) |
|
3326
|
345 |
18 |
if (defined $basestr) |
|
3328
|
63 |
282 |
if (defined $g) { } |
|
|
51 |
231 |
elsif ($ctx->is_superglobal($basestr)) { } |
|
|
19 |
212 |
elsif (is_variable($basestr)) { } |
|
|
7 |
205 |
elsif ($basestr =~ /^#elem\d+$/) { } |
|
3329
|
24 |
39 |
if ($ctx->{'infunction'}) |
|
3334
|
0 |
0 |
defined $basestr ? : |
|
|
0 |
63 |
if $ctx->{'log'} |
|
3336
|
9 |
54 |
if (defined $basestr and $basestr eq "#unresolved") |
|
3339
|
40 |
23 |
if (defined $basestr) |
|
3346
|
0 |
51 |
if (defined $val) |
|
3350
|
9 |
10 |
if ($basestr eq $basevar) { } |
|
3360
|
0 |
0 |
defined $idxstr ? : |
|
|
0 |
0 |
defined $basestr ? : |
|
|
0 |
300 |
if $ctx->{'log'} |
|
3362
|
7 |
293 |
if (defined $basestr and $basestr eq '#unresolved') { } |
|
|
31 |
262 |
elsif (defined $basestr and is_strval($basestr) and not is_null($basestr) and defined $idxstr and is_strval($idxstr)) { } |
|
|
169 |
93 |
elsif (defined $basestr and is_array($basestr) and defined $idxstr) { } |
|
|
20 |
73 |
elsif (not exists $ctx->{'skip'}{'null'} || defined $basestr and !$ctx->is_superglobal($basevar) || $basevar =~ /^\$GLOBALS$/) { } |
|
3363
|
7 |
0 |
defined $i ? : |
|
3370
|
31 |
0 |
if ($pos =~ /^[\d\.]+$/) |
|
3372
|
3 |
28 |
if ($pos >= length $baseval) { } |
|
3379
|
3 |
0 |
if ($pos == length $baseval) |
|
3386
|
0 |
28 |
if $ctx->{'log'} |
|
3392
|
3 |
166 |
if is_null($idxstr) |
|
3394
|
135 |
34 |
if (defined $arrval) |
|
3395
|
0 |
135 |
if $ctx->{'log'} |
|
3399
|
18 |
2 |
unless ($ctx->{'tainted'}) |
|
3400
|
18 |
0 |
defined $i ? : |
|
3407
|
116 |
0 |
if (exists $ctx->{'simplify'}{'elem'}) |
|
3408
|
116 |
0 |
if (defined $i) |
|
3409
|
36 |
80 |
if ($v ne $basevar or $i ne $idxstr) |
|
3411
|
0 |
36 |
if $ctx->{'log'} |
|
3421
|
1030 |
588 |
if ($op eq "=" and defined $v2) |
|
3424
|
11 |
1019 |
if ($v1 =~ /^#obj\d+$/) |
|
3426
|
7 |
4 |
if (defined $inst) |
|
3428
|
0 |
7 |
if $ctx->{'log'} |
|
3432
|
9 |
1021 |
if ($v1 =~ /^#scope\d+$/) |
|
3434
|
9 |
0 |
if (defined $scope and is_variable($val)) |
|
3436
|
0 |
9 |
if $ctx->{'log'} |
|
3440
|
13 |
1017 |
if ($v1 =~ /^#expr\d+$/) |
|
3444
|
10 |
3 |
if (defined $basevar and $basevar ne $v1) |
|
3445
|
0 |
10 |
if $ctx->{'log'} |
|
3451
|
7 |
1023 |
is_instvar($vv1) ? : |
|
3453
|
1030 |
0 |
if (defined $v2) |
|
3458
|
865 |
165 |
if (is_variable($vv1)) { } |
|
|
148 |
17 |
elsif ($v1 =~ /^#elem\d+$/) { } |
|
|
8 |
9 |
elsif ($v1 =~ /^#arr\d+$/) { } |
|
3459
|
6 |
859 |
if (defined $op2 and $op2 =~ /^#ref\d+$/) { } |
|
|
3 |
856 |
elsif (defined $v2 and $v2 =~ /^\$GLOBALS$/) { } |
|
|
5 |
851 |
elsif (defined $v2 and $ctx->is_superglobal($v2)) { } |
|
|
133 |
718 |
elsif ($ctx->is_unresolved_assignment($op2)) { } |
|
|
1 |
717 |
elsif (is_block($op2)) { } |
|
3466
|
0 |
6 |
if $ctx->{'log'} |
|
3472
|
0 |
3 |
if $ctx->{'log'} |
|
3487
|
1 |
4 |
if (defined $a and is_array($a)) { } |
|
3491
|
0 |
1 |
if $ctx->{'log'} |
|
3498
|
0 |
4 |
if $ctx->{'log'} |
|
3504
|
120 |
13 |
if ($in_block or not exists $ctx->{'varhist'}) |
|
3505
|
0 |
120 |
if $ctx->{'log'} |
|
3506
|
25 |
95 |
if ($v1 ne $vv1_sim or $v2 ne $op2) |
|
3511
|
0 |
13 |
if $ctx->{'log'} |
|
3520
|
1 |
0 |
if (scalar @$a > 0) { } |
|
3524
|
0 |
1 |
if $ctx->{'log'} |
|
3527
|
0 |
0 |
if $ctx->{'log'} |
|
3531
|
0 |
717 |
if $ctx->{'log'} |
|
3534
|
669 |
61 |
if ($in_block) { } |
|
3535
|
218 |
451 |
if ($v1 ne $vv1_sim or $v2 ne $op2) |
|
3551
|
123 |
25 |
if ($basevar =~ /^(\#elem\d+)$/) { } |
|
3561
|
10 |
138 |
if (defined $basestr and is_null($basestr)) |
|
3564
|
0 |
148 |
if (defined $basestr and $basestr eq "#unresolved") |
|
3567
|
123 |
25 |
if (defined $i) |
|
3571
|
148 |
0 |
if (defined $basevar) |
|
3572
|
0 |
0 |
defined $idxstr ? : |
|
|
0 |
0 |
defined $parent ? : |
|
|
0 |
0 |
defined $basestr ? : |
|
|
0 |
148 |
if $ctx->{'log'} |
|
3574
|
25 |
123 |
if (not $has_index) { } |
|
|
3 |
120 |
elsif (defined $basestr and is_strval($basestr) and not is_null($basestr) and defined $idxstr) { } |
|
|
118 |
2 |
elsif (not defined $basestr or is_array($basestr)) { } |
|
3575
|
5 |
20 |
if ($ctx->is_unresolved_assignment($op2)) { } |
|
3582
|
3 |
0 |
if (is_strval($op2)) |
|
3595
|
0 |
3 |
if ($@) |
|
3601
|
0 |
3 |
if $ctx->{'log'} |
|
3605
|
118 |
0 |
if (defined $basestr) { } |
|
3607
|
25 |
93 |
if (not defined $idxstr) { } |
|
|
92 |
1 |
elsif (is_strval($idxstr)) { } |
|
3610
|
4 |
21 |
if ($ctx->is_unresolved_assignment($op2)) { } |
|
3615
|
0 |
4 |
if $ctx->{'log'} |
|
3618
|
0 |
21 |
if $ctx->{'log'} |
|
3622
|
7 |
85 |
if ($ctx->is_unresolved_assignment($op2)) { } |
|
|
5 |
80 |
elsif (is_null($idxstr)) { } |
|
3625
|
0 |
7 |
if $ctx->{'log'} |
|
3629
|
0 |
5 |
if $ctx->{'log'} |
|
3632
|
0 |
80 |
if $ctx->{'log'} |
|
3636
|
0 |
0 |
if ($ctx->is_unresolved_assignment($op2)) |
|
3644
|
118 |
0 |
if (exists $ctx->{'simplify'}{'expr'}) |
|
3646
|
42 |
76 |
if ($v ne $parent or defined $idxstr and $i ne $idxstr) |
|
3649
|
40 |
1 |
unless (is_instvar($parent) or is_instvar($basevar)) |
|
3653
|
108 |
10 |
if ($in_block or not exists $ctx->{'varhist'}) |
|
3654
|
61 |
47 |
if ($v1 ne $op1 or $v2 ne $op2) |
|
3656
|
0 |
61 |
if $ctx->{'log'} |
|
3664
|
3 |
7 |
if ($v1 ne $op1 or $v2 ne $op2) { } |
|
3665
|
0 |
3 |
if $ctx->{'log'} |
|
3667
|
0 |
7 |
if $ctx->{'log'} |
|
3671
|
9 |
1 |
if (is_strval($op2) or is_array($op2)) |
|
3687
|
6 |
2 |
if (is_array($op2)) { } |
|
|
1 |
1 |
elsif (is_strval($op2)) { } |
|
3693
|
7 |
1 |
if (defined $arr_s) |
|
3698
|
1 |
14 |
unless defined $dst |
|
3700
|
12 |
2 |
if (defined $src) |
|
3701
|
10 |
2 |
if (is_variable($dst)) { } |
|
|
2 |
0 |
elsif ($dst =~ /^#elem\d+$/) { } |
|
3702
|
0 |
10 |
if ($ctx->is_unresolved_assignment($src)) { } |
|
3710
|
0 |
2 |
if $ctx->{'log'} |
|
3715
|
2 |
0 |
unless ($had_assigns) |
|
3726
|
4 |
3 |
if ($in_block or not exists $ctx->{'varhist'}) |
|
3727
|
0 |
4 |
if ($v2 ne $op2) |
|
3729
|
0 |
0 |
if $ctx->{'log'} |
|
3737
|
463 |
0 |
if (exists $ctx->{'simplify'}{'expr'}) |
|
3738
|
2 |
461 |
if ($v1 =~ /^#elem\d+$/) |
|
3740
|
2 |
0 |
unless ($ctx->is_superglobal($vv1)) |
|
3741
|
0 |
2 |
unless (is_variable($vv1) or $vv1 =~ /^#elem\d+$/) |
|
3748
|
4 |
459 |
if ($v1 ne $vv1_sim or $v2 ne $op2) |
|
3752
|
0 |
4 |
if $ctx->{'log'} |
|
3760
|
447 |
141 |
if (defined $v1) |
|
3761
|
0 |
447 |
if ($v1 =~ /^#stmt\d+$/) { } |
|
3768
|
39 |
549 |
if (not defined $v1 and defined $v2 and $op eq 'new') { } |
|
|
102 |
447 |
elsif (not defined $v1 and defined $v2) { } |
|
|
49 |
398 |
elsif (defined $v1 and is_strval($op1) and not defined $v2) { } |
|
|
384 |
14 |
elsif (defined $v1 and defined $v2) { } |
|
3769
|
39 |
0 |
if ($v2 =~ /^#call\d+$/) |
|
3781
|
34 |
1 |
if (defined $class and exists $ctx->{'varmap'}{'inst'}{$name}) |
|
3785
|
0 |
34 |
if $ctx->{'log'} |
|
3790
|
1 |
33 |
if ($arg_changed) |
|
3791
|
0 |
1 |
$args->[$_] =~ /^(#inst\d+)$/ ? : |
|
3797
|
0 |
34 |
if $ctx->{'log'} |
|
3808
|
26 |
33 |
if ($m =~ /^#fun\d+$/) |
|
3810
|
26 |
0 |
if (defined $f and is_symbol($f)) |
|
3814
|
0 |
26 |
if $ctx->{'log'} |
|
3823
|
30 |
4 |
unless (defined $f) |
|
3827
|
2 |
28 |
if (defined $f) |
|
3828
|
0 |
2 |
if $ctx->{'log'} |
|
3832
|
6 |
28 |
if (defined $f) |
|
3839
|
5 |
0 |
unless ($ctx->{'incall'}) |
|
3840
|
5 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
3841
|
0 |
5 |
if ($arg_changed) |
|
3842
|
0 |
0 |
$args->[$_] =~ /^(#inst\d+)$/ ? : |
|
3844
|
0 |
0 |
if ($v2 ne $c2) |
|
3846
|
0 |
0 |
if $ctx->{'log'} |
|
3856
|
48 |
54 |
if ($op eq '$') { } |
|
|
19 |
35 |
elsif ($op eq '--' || $op eq '++' and is_variable($v2)) { } |
|
3858
|
42 |
6 |
if (defined $var1) |
|
3861
|
6 |
0 |
if (exists $ctx->{'simplify'}{'expr'}) |
|
3862
|
5 |
1 |
if (is_variable($op2) and $v2 ne $op2) |
|
3866
|
0 |
5 |
if $ctx->{'log'} |
|
3874
|
18 |
1 |
if (is_strval($op2)) { } |
|
3877
|
18 |
0 |
if (defined $val) |
|
3878
|
0 |
18 |
if $ctx->{'log'} |
|
3890
|
21 |
14 |
if (is_strval($op2) or is_array($op2)) |
|
3892
|
21 |
0 |
if (defined $k) { } |
|
3893
|
0 |
21 |
if $ctx->{'log'} |
|
3900
|
16 |
0 |
if (exists $ctx->{'simplify'}{'expr'}) |
|
3901
|
0 |
16 |
if (is_instvar($op2)) |
|
3904
|
8 |
8 |
if ($v2 ne $op2) |
|
3908
|
0 |
8 |
if $ctx->{'log'} |
|
3916
|
49 |
0 |
if (is_strval($op1)) { } |
|
3918
|
49 |
0 |
if (defined $val) |
|
3919
|
0 |
49 |
if $ctx->{'log'} |
|
3927
|
27 |
22 |
if (defined $res and not $res =~ /^#expr\d+$/) |
|
3938
|
0 |
384 |
if ($v1 =~ /^#stmt\d+$/) { } |
|
3942
|
13 |
319 |
if (not $in_block and $op eq '||' || $op eq 'or' || $op eq '&&' || $op eq 'and' || $op eq '?' || $op eq ':') |
|
3943
|
0 |
23 |
if $ctx->{'log'} |
|
3949
|
254 |
130 |
if (is_strval($op1) || is_array($op1) and is_strval($op2) || is_array($op2)) { } |
|
|
15 |
115 |
elsif ($op eq '?') { } |
|
|
0 |
115 |
elsif ($op eq '===' and $op1 eq '#null') { } |
|
|
0 |
115 |
elsif ($op eq '===' and $op2 eq '#null') { } |
|
|
0 |
115 |
elsif ($op eq '==' and $op1 eq '#null') { } |
|
|
1 |
223 |
elsif ($op eq '==' and $op2 eq '#null') { } |
|
3950
|
242 |
12 |
if ($op ne "?" and $op ne ":") |
|
3952
|
241 |
1 |
if (defined $k) { } |
|
3953
|
0 |
241 |
if $ctx->{'log'} |
|
3960
|
7 |
0 |
if (is_strval($op1) || is_array($op1) and $op2 =~ /^#expr\d+$/ and $parser->{'strmap'}{$op2}[0] eq ":") |
|
3965
|
0 |
7 |
if (is_array($op1)) |
|
3970
|
5 |
2 |
if ($val) { } |
|
3979
|
0 |
0 |
if (defined $k) |
|
3984
|
0 |
0 |
if (defined $k) |
|
3989
|
0 |
0 |
if (defined $k) |
|
3994
|
0 |
1 |
if (defined $k) |
|
3999
|
136 |
0 |
if (exists $ctx->{'simplify'}{'expr'}) |
|
4000
|
0 |
136 |
if (is_instvar($op1)) |
|
4003
|
0 |
136 |
if (is_instvar($op2)) |
|
4006
|
40 |
96 |
if ($v1 ne $op1 or $v2 ne $op2) |
|
4010
|
0 |
40 |
if $ctx->{'log'} |
|
4021
|
26 |
707 |
if (is_variable($name) or $name =~ /^#elem\d+$/ or $name =~ /^#expr\d+$/ or $name =~ /^#stmt\d+$/ or is_block($name)) { } |
|
|
28 |
679 |
elsif ($name =~ /^#obj\d+$/) { } |
|
|
24 |
655 |
elsif ($name =~ /^#scope\d+$/) { } |
|
|
2 |
653 |
elsif ($name =~ /^#ns\d+$/) { } |
|
|
635 |
18 |
elsif (is_symbol($name)) { } |
|
4023
|
8 |
18 |
if ($s =~ /^#fun\d+$/) { } |
|
|
16 |
2 |
elsif (not is_null($s)) { } |
|
4027
|
13 |
3 |
if (is_strval($s)) { } |
|
4034
|
0 |
26 |
if $ctx->{'log'} |
|
4037
|
18 |
10 |
if (defined $inst) |
|
4038
|
18 |
0 |
if (is_symbol($prop)) { } |
|
4042
|
0 |
0 |
if ($m ne $prop) |
|
4044
|
0 |
0 |
if $ctx->{'log'} |
|
4048
|
0 |
28 |
if $ctx->{'log'} |
|
4051
|
21 |
3 |
if (defined $scope) |
|
4052
|
21 |
0 |
if (is_symbol($val)) |
|
4057
|
0 |
24 |
if $ctx->{'log'} |
|
4060
|
2 |
0 |
if (defined $ns) |
|
4064
|
0 |
2 |
if $ctx->{'log'} |
|
4073
|
11 |
722 |
if $cmd =~ /^#fun\d+$/ |
|
4074
|
722 |
11 |
unless (defined $fun) |
|
4077
|
198 |
524 |
if (defined $fun) |
|
4081
|
209 |
524 |
if (defined $fun) |
|
4083
|
4 |
205 |
if (defined $cmd1) |
|
4084
|
0 |
4 |
if $ctx->{'log'} |
|
4094
|
205 |
528 |
if (defined $fun) { } |
|
|
56 |
472 |
elsif (lc $cmd eq 'eval' and scalar @$arglist == 1) { } |
|
|
4 |
468 |
elsif ($cmd eq 'assert' and scalar @$arglist == 1) { } |
|
4095
|
0 |
205 |
if (exists $ctx->{'skip'}{'call'}) { } |
|
4101
|
0 |
205 |
if (exists $ctx->{'with'}{'translate'}) |
|
4103
|
0 |
0 |
if (defined $perl) |
|
4104
|
0 |
0 |
if $ctx->{'log'} |
|
4106
|
0 |
0 |
if ($@) { } |
|
4109
|
0 |
0 |
if (scalar @$args == 1 and is_strval($args->[0])) |
|
4112
|
0 |
0 |
if ($@) { } |
|
4115
|
0 |
0 |
defined $res ? : |
|
|
0 |
0 |
if $ctx->{'log'} |
|
4116
|
0 |
0 |
if (defined $res) |
|
4118
|
0 |
0 |
if ($res =~ /^[0-9]+$/) { } |
|
4130
|
205 |
0 |
unless (defined $key) |
|
4133
|
5 |
200 |
unless (defined $key) |
|
4134
|
0 |
5 |
defined $code ? : |
|
4136
|
0 |
5 |
if (keys %{$$info{'unresolved'};}) { } |
|
4137
|
0 |
5 |
defined $code ? : |
|
4141
|
0 |
0 |
defined $code ? : |
|
4144
|
205 |
0 |
if (defined $key) { } |
|
4147
|
181 |
24 |
if (defined $code) |
|
4148
|
169 |
12 |
if (is_block($code)) { } |
|
4155
|
199 |
6 |
if ($key ne "#construct") |
|
4157
|
56 |
143 |
if ($cmd ne $name) |
|
4160
|
6 |
50 |
if ($cmd =~ /^#fun\d+$/ and is_variable($name)) { } |
|
|
0 |
50 |
elsif (is_instvar($cmd)) { } |
|
4176
|
173 |
26 |
if (defined $code and not $in_block) { } |
|
4179
|
13 |
13 |
if ($name_changed or $arg_changed) { } |
|
4180
|
0 |
8 |
$args->[$_] =~ /^(#inst\d+)$/ ? : |
|
4186
|
7 |
192 |
if ($key eq '#notaint') { } |
|
|
4 |
188 |
elsif ($in_block) { } |
|
4189
|
0 |
4 |
if (is_strval($key) || is_array($key) || _anon_func_call($parser, $key) and defined $code and $parser->is_empty_block($code)) { } |
|
4191
|
0 |
0 |
if $ctx->{'log'} |
|
4201
|
62 |
126 |
if ($key eq "#noreturn") |
|
4206
|
6 |
199 |
if ($key eq "#construct") |
|
4210
|
6 |
0 |
if (defined $methodname) |
|
4213
|
6 |
0 |
unless ($f = _anon_func_call($parser, $code)) |
|
4220
|
0 |
0 |
defined $code ? : |
|
|
0 |
205 |
if $ctx->{'log'} |
|
4242
|
48 |
8 |
if (defined $blk) |
|
4247
|
48 |
8 |
if (defined $key) |
|
4252
|
0 |
48 |
if $ctx->{'log'} |
|
4254
|
13 |
35 |
if (is_block($key)) { } |
|
4264
|
3 |
45 |
if (defined $r) |
|
4268
|
0 |
3 |
if ($r ne $r2) |
|
4271
|
1 |
2 |
if (scalar @seq > 0) { } |
|
4276
|
0 |
1 |
if $ctx->{'log'} |
|
4278
|
0 |
2 |
if $ctx->{'log'} |
|
4288
|
0 |
45 |
if (not $resolved_eval and scalar @seq == 1) |
|
4290
|
0 |
0 |
if $ctx->{'log'} |
|
4294
|
45 |
0 |
if ($key ne "#null") |
|
4297
|
0 |
45 |
if $ctx->{'log'} |
|
4303
|
8 |
0 |
if (exists $ctx->{'simplify'}{'call'}) |
|
4304
|
3 |
5 |
if ($args->[0] =~ /^#call\d+$/) |
|
4308
|
1 |
2 |
unless (PHP::Decode::Func::func_may_return_string($name)) |
|
4311
|
0 |
1 |
if $ctx->{'log'} |
|
4321
|
4 |
0 |
if (is_strval($key)) |
|
4327
|
1 |
467 |
if ($cmd =~ /^\\(.*)$/) |
|
4332
|
24 |
444 |
if (defined $f and exists $f->{'param'}) { } |
|
4338
|
187 |
281 |
if (defined $key) |
|
4339
|
0 |
187 |
if $ctx->{'log'} |
|
4341
|
3 |
184 |
if ($key eq "#noreturn") |
|
4343
|
0 |
3 |
if ($name ne $cmdsim or $arg_changed) |
|
4344
|
0 |
0 |
$args->[$_] =~ /^(#inst\d+)$/ ? : |
|
4346
|
0 |
0 |
if $ctx->{'log'} |
|
4351
|
55 |
226 |
if (defined $f) { } |
|
4352
|
2 |
53 |
if (exists $f->{'param'}) |
|
4358
|
229 |
52 |
if (PHP::Decode::Func::func_may_call_callbacks($cmd)) |
|
4364
|
288 |
0 |
if (exists $ctx->{'simplify'}{'call'}) |
|
4365
|
0 |
288 |
if (is_instvar($cmdsim)) |
|
4368
|
2 |
159 |
$args->[$_] =~ /^(#inst\d+)$/ ? : |
|
4370
|
69 |
219 |
if ($name ne $cmdsim or $arg_changed) |
|
4385
|
2018 |
120 |
if ($type ne "brace" and $type ne "expr") |
|
4387
|
810 |
1208 |
if (defined $rhs or _is_increment_op($parser, $p)) |
|
4388
|
0 |
810 |
if $ctx->{'log'} |
|
4392
|
810 |
1328 |
$keep_assign ? : |
|
4393
|
0 |
2138 |
unless (defined $v) |
|
4400
|
2018 |
120 |
if ($type ne 'brace' and $type ne 'expr') { } |
|
4402
|
141 |
1877 |
if ($v1 ne $v) { } |
|
4403
|
0 |
141 |
if (exists $ctx->{'with'}{'optimize_block_vars'}) { } |
|
4417
|
1027 |
1111 |
if ($p ne $v) |
|
4421
|
256 |
1882 |
if (defined $f) |
|
4422
|
9 |
247 |
if (scalar @args < scalar @$arglist) |
|
4430
|
92 |
482 |
if (scalar @args == 1 and is_strval($args[0]) || $args[0] =~ /^#fun\d+$/) |
|
4431
|
0 |
92 |
if $ctx->{'log'} |
|
4434
|
743 |
464 |
if ($changed) |
|
4441
|
184 |
526 |
if ($cmd eq 'echo') { } |
|
|
0 |
526 |
elsif ($cmd eq 'print') { } |
|
|
10 |
516 |
elsif ($cmd eq 'global') { } |
|
|
15 |
501 |
elsif ($cmd eq 'static') { } |
|
|
9 |
492 |
elsif ($cmd eq 'const') { } |
|
|
254 |
238 |
elsif ($cmd eq 'return') { } |
|
|
5 |
233 |
elsif ($cmd eq 'unset') { } |
|
|
2 |
231 |
elsif ($cmd eq 'break') { } |
|
|
0 |
231 |
elsif ($cmd eq 'continue') { } |
|
|
10 |
221 |
elsif ($cmd eq 'namespace') { } |
|
|
0 |
221 |
elsif ($cmd =~ /^(include|include_once|require|require_once)$/) { } |
|
|
150 |
71 |
elsif ($cmd eq 'if') { } |
|
|
10 |
61 |
elsif ($cmd eq 'while') { } |
|
|
7 |
54 |
elsif ($cmd eq 'do') { } |
|
|
23 |
31 |
elsif ($cmd eq 'for') { } |
|
|
19 |
12 |
elsif ($cmd eq 'foreach') { } |
|
|
9 |
3 |
elsif ($cmd eq 'switch') { } |
|
4448
|
107 |
86 |
if (not is_strval($p) or is_const($p)) { } |
|
4451
|
88 |
19 |
if ($v ne $p) |
|
4454
|
31 |
76 |
unless (is_strval($v)) |
|
4463
|
4 |
189 |
is_const($arglist->[$_]) && !$parser->is_magic_const($arglist->[$_]) && !exists($ctx->{'defines'}{$parser->{'strmap'}{$arglist->[$_]}}) ? : |
|
4470
|
4 |
180 |
if ($all_str and scalar @param > 1) |
|
4476
|
119 |
65 |
unless ($ctx->{'skipundef'}) |
|
4477
|
117 |
2 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'}) |
|
4478
|
1 |
116 |
if (exists $ctx->{'globals'}{'stdout'}{'ob'}) { } |
|
4485
|
184 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
4486
|
84 |
100 |
if ($changed) |
|
4487
|
5 |
79 |
if (scalar @paramsim > 1) |
|
4491
|
0 |
84 |
if $ctx->{'log'} |
|
4500
|
0 |
0 |
unless ($ctx->{'skipundef'}) |
|
4501
|
0 |
0 |
if (exists $ctx->{'globals'} and exists $ctx->{'globals'}{'stdout'}) |
|
4502
|
0 |
0 |
if (exists $ctx->{'globals'}{'stdout'}{'ob'}) { } |
|
4509
|
0 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
4510
|
0 |
0 |
if ($v ne $arg) |
|
4512
|
0 |
0 |
if $ctx->{'log'} |
|
4522
|
10 |
0 |
if (is_variable($v)) |
|
4523
|
0 |
10 |
if ($ctx->is_superglobal($v)) { } |
|
4524
|
0 |
0 |
if $ctx->{'log'} |
|
4527
|
0 |
10 |
if $ctx->{'log'} |
|
4537
|
10 |
5 |
if (is_variable($v)) { } |
|
|
5 |
0 |
elsif ($v =~ /^#expr\d+$/) { } |
|
4538
|
0 |
10 |
if ($ctx->is_superglobal($v)) { } |
|
4539
|
0 |
0 |
if $ctx->{'log'} |
|
4541
|
3 |
7 |
if ($ctx->{'infunction'}) { } |
|
|
7 |
0 |
elsif (exists $ctx->{'class_scope'}) { } |
|
4542
|
1 |
2 |
unless (exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$v}) |
|
4544
|
0 |
1 |
if $ctx->{'log'} |
|
4547
|
7 |
0 |
unless (exists $ctx->{'varmap'}{'inst'}{$ctx->{'class_scope'}}{$v}) |
|
4549
|
0 |
7 |
if $ctx->{'log'} |
|
4552
|
0 |
0 |
if $ctx->{'log'} |
|
4557
|
5 |
0 |
if ($op eq '=') { } |
|
4558
|
0 |
5 |
if ($ctx->is_superglobal($v1)) { } |
|
4559
|
0 |
0 |
if $ctx->{'log'} |
|
4561
|
3 |
2 |
if ($ctx->{'infunction'}) { } |
|
|
2 |
0 |
elsif (exists $ctx->{'class_scope'}) { } |
|
4562
|
1 |
2 |
unless (exists $ctx->{'varmap'}{'static'}{$ctx->{'infunction'}}{$v1}) |
|
4564
|
0 |
1 |
if $ctx->{'log'} |
|
4567
|
2 |
0 |
unless (exists $ctx->{'varmap'}{'inst'}{$ctx->{'class_scope'}}{$v1}) |
|
4569
|
0 |
2 |
if $ctx->{'log'} |
|
4572
|
0 |
0 |
if $ctx->{'log'} |
|
4588
|
9 |
0 |
if ($v =~ /^#expr\d+$/) { } |
|
4591
|
9 |
0 |
if ($op eq '=') { } |
|
4592
|
0 |
9 |
do {
$ctx->{'infunction'}
} ? : |
|
|
9 |
0 |
is_const($v1) ? : |
|
4593
|
0 |
0 |
if $ctx->{'log'} |
|
4595
|
0 |
0 |
if $ctx->{'log'} |
|
4600
|
4 |
5 |
if (exists $ctx->{'class_scope'}) |
|
4603
|
4 |
5 |
if ($ctx->{'namespace'}) |
|
4607
|
0 |
9 |
if $ctx->{'log'} |
|
4620
|
107 |
147 |
if (defined $res and $arg ne $res) |
|
4634
|
1 |
4 |
if (is_variable($p)) { } |
|
|
4 |
0 |
elsif ($p =~ /^(\#elem\d+)$/) { } |
|
4635
|
1 |
0 |
if (exists $ctx->{'varmap'}{$p}) { } |
|
4636
|
0 |
1 |
if $ctx->{'log'} |
|
4638
|
0 |
0 |
if $ctx->{'log'} |
|
4648
|
4 |
0 |
if (defined $basevar) |
|
4649
|
3 |
1 |
if ($has_index) { } |
|
4651
|
2 |
1 |
if (defined $basestr and is_array($basestr) and defined $idxstr) { } |
|
4653
|
0 |
2 |
if is_null($idxstr) |
|
4655
|
2 |
0 |
if (defined $arrval) |
|
4657
|
0 |
2 |
if $ctx->{'log'} |
|
4663
|
0 |
1 |
if $ctx->{'log'} |
|
4666
|
0 |
1 |
if (exists $ctx->{'varmap'}{$basevar}) { } |
|
4667
|
0 |
0 |
if $ctx->{'log'} |
|
4669
|
0 |
1 |
if $ctx->{'log'} |
|
4682
|
1 |
2 |
if ($v ne $p) |
|
4690
|
5 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
4691
|
2 |
3 |
if ($changed) |
|
4693
|
0 |
2 |
if $ctx->{'log'} |
|
4707
|
2 |
8 |
if (defined $block) |
|
4709
|
1 |
1 |
if ($block1 ne $block) |
|
4721
|
0 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
4722
|
0 |
0 |
if ($v ne $arg) |
|
4724
|
0 |
0 |
if $ctx->{'log'} |
|
4738
|
0 |
0 |
defined $cond ? : |
|
|
0 |
150 |
if $ctx->{'log'} |
|
4739
|
48 |
102 |
if (defined $cond and is_strval($cond) || is_array($cond)) |
|
4743
|
1 |
47 |
if (is_array($cond)) |
|
4747
|
25 |
23 |
if ($val) { } |
|
|
11 |
12 |
elsif (defined $else) { } |
|
4760
|
4 |
44 |
if defined $fin |
|
4762
|
4 |
44 |
if (scalar @seq > 1) { } |
|
|
32 |
12 |
elsif (scalar @seq > 0) { } |
|
4775
|
44 |
58 |
if ($expr ne $cond) |
|
4789
|
14 |
88 |
if (defined $else) |
|
4794
|
14 |
88 |
if (defined $else) |
|
4797
|
0 |
102 |
if (is_instvar($cond)) |
|
4800
|
28 |
30 |
if ($cond ne $expr or $then ne $then1 or defined $else and $else ne $else1) |
|
4804
|
2 |
70 |
if ($then ne $then1 and not is_block($then1)) |
|
4807
|
0 |
10 |
if (defined $else and $else ne $else1 and not is_block($else1)) |
|
4811
|
0 |
72 |
if $ctx->{'log'} |
|
4814
|
8 |
94 |
if (defined $fin) |
|
4818
|
8 |
0 |
if (scalar @seq > 1) { } |
|
|
0 |
0 |
elsif (scalar @seq > 0) { } |
|
4832
|
10 |
0 |
unless (exists $ctx->{'skip'}{'loop'}) |
|
4842
|
6 |
4 |
if ($i == 0 and is_strval($cond) || is_array($cond)) |
|
4846
|
1 |
5 |
if (is_array($cond)) |
|
4850
|
0 |
6 |
unless ($val) |
|
4856
|
0 |
18 |
if $ctx->{'log'} |
|
4857
|
14 |
4 |
if (is_strval($cond) or is_array($cond)) { } |
|
|
4 |
0 |
elsif ($i == 0) { } |
|
4859
|
2 |
12 |
if (is_array($cond)) |
|
4863
|
3 |
11 |
unless ($val) |
|
4865
|
0 |
3 |
unless (defined $res) |
|
4866
|
0 |
0 |
if $ctx->{'log'} |
|
4883
|
0 |
11 |
unless (defined $res) |
|
4891
|
2 |
0 |
if (defined $u or defined $f and !defined($r) || $f ne $r) |
|
4892
|
2 |
0 |
defined $f ? : |
|
4896
|
0 |
9 |
if $ctx->{'log'} |
|
4897
|
1 |
8 |
if (defined $r) |
|
4898
|
0 |
1 |
if $ctx->{'log'} |
|
4904
|
0 |
8 |
if (defined $fin) |
|
4910
|
0 |
8 |
if ($i >= $ctx->{'max_loop_while'}) |
|
4914
|
0 |
8 |
if (loop_level($parser) > 1 and loop_val($parser, $i) >= 2 * $ctx->{'max_loop'}) |
|
4918
|
0 |
8 |
if ($i >= $ctx->{'max_loop_const'} and is_strval($expr)) |
|
4927
|
4 |
6 |
if (defined $res) |
|
4931
|
1 |
3 |
if (defined $fin) |
|
4936
|
2 |
2 |
if (scalar @seq > 1) { } |
|
|
2 |
0 |
elsif (scalar @seq > 0) { } |
|
4941
|
0 |
4 |
if $ctx->{'log'} |
|
4946
|
6 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
4947
|
0 |
6 |
if $ctx->{'log'} |
|
4969
|
0 |
6 |
if (is_instvar($expr0)) |
|
4972
|
0 |
6 |
if ($expr ne $expr0 or $block ne $block0) |
|
4988
|
7 |
0 |
if (defined $res) |
|
4993
|
7 |
0 |
unless (exists $ctx->{'skip'}{'loop'}) |
|
5000
|
0 |
11 |
if $ctx->{'log'} |
|
5001
|
10 |
1 |
if (is_strval($cond) or is_array($cond)) { } |
|
|
1 |
0 |
elsif ($i == 0) { } |
|
5003
|
0 |
10 |
if (is_array($cond)) |
|
5007
|
6 |
4 |
unless ($val) |
|
5022
|
0 |
4 |
unless (defined $res) |
|
5030
|
0 |
0 |
if (defined $u or defined $f and !defined($r) || $f ne $r) |
|
5031
|
0 |
0 |
defined $f ? : |
|
5035
|
0 |
4 |
if $ctx->{'log'} |
|
5036
|
0 |
4 |
if (defined $r) |
|
5037
|
0 |
0 |
if $ctx->{'log'} |
|
5043
|
0 |
4 |
if (defined $fin) |
|
5049
|
0 |
4 |
if ($i >= $ctx->{'max_loop'}) |
|
5053
|
0 |
4 |
if (loop_level($parser) > 1 and loop_val($parser, $i) >= 2 * $ctx->{'max_loop'}) |
|
5057
|
0 |
4 |
if ($i >= $ctx->{'max_loop_const'} and is_strval($expr)) |
|
5066
|
6 |
1 |
if (defined $res) |
|
5070
|
1 |
5 |
if (defined $fin) |
|
5075
|
2 |
4 |
if (scalar @seq > 1) { } |
|
|
4 |
0 |
elsif (scalar @seq > 0) { } |
|
5080
|
0 |
6 |
if $ctx->{'log'} |
|
5084
|
1 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
5085
|
0 |
1 |
if $ctx->{'log'} |
|
5107
|
0 |
1 |
if (is_instvar($expr0)) |
|
5110
|
0 |
1 |
if ($expr ne $expr0 or $block ne $block0) |
|
5124
|
23 |
0 |
unless (exists $ctx->{'skip'}{'loop'}) |
|
5140
|
0 |
53 |
if $ctx->{'log'} |
|
5141
|
2 |
51 |
if ($parser->is_empty_block($cond)) |
|
5144
|
48 |
5 |
if (is_strval($cond) or is_array($cond)) { } |
|
|
5 |
0 |
elsif ($i == 0) { } |
|
5146
|
0 |
48 |
if (is_array($cond)) |
|
5150
|
15 |
33 |
unless ($val) |
|
5152
|
3 |
12 |
unless (defined $res) |
|
5153
|
0 |
3 |
if $ctx->{'log'} |
|
5168
|
0 |
33 |
unless (defined $res) |
|
5176
|
3 |
0 |
if (defined $u or defined $f and !defined($r) || $f ne $r) |
|
5177
|
0 |
3 |
defined $f ? : |
|
5181
|
0 |
30 |
if $ctx->{'log'} |
|
5182
|
0 |
30 |
if (defined $r) |
|
5183
|
0 |
0 |
if $ctx->{'log'} |
|
5191
|
0 |
30 |
if (defined $fin) |
|
5198
|
0 |
30 |
if $ctx->{'log'} |
|
5200
|
0 |
30 |
if ($i >= $ctx->{'max_loop'}) |
|
5204
|
0 |
30 |
if (loop_level($parser) > 1 and loop_val($parser, $i) >= 2 * $ctx->{'max_loop'}) |
|
5212
|
15 |
8 |
if (defined $res) |
|
5216
|
14 |
1 |
if (defined $fin) |
|
5223
|
14 |
1 |
if (scalar @seq > 1) { } |
|
|
1 |
0 |
elsif (scalar @seq > 0) { } |
|
5228
|
0 |
15 |
if $ctx->{'log'} |
|
5233
|
8 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
5234
|
0 |
8 |
if $ctx->{'log'} |
|
5243
|
0 |
8 |
if ($pre ne $pre0) |
|
5265
|
0 |
8 |
if (is_instvar($expr0)) |
|
5268
|
1 |
7 |
if ($pre ne $pre0 or $expr ne $expr0 or $post ne $post0 or $block ne $block0) |
|
5285
|
13 |
6 |
if (defined $key) |
|
5287
|
13 |
0 |
defined $_basevar2 ? : |
|
5290
|
19 |
0 |
defined $_basevar ? : |
|
5293
|
19 |
0 |
unless (exists $ctx->{'skip'}{'loop'}) |
|
5300
|
11 |
8 |
if (is_array($expr0)) { } |
|
5307
|
0 |
11 |
if (scalar @$keys == 0 and not $ctx->{'tainted'}) |
|
5308
|
0 |
0 |
if $ctx->{'log'} |
|
5312
|
17 |
0 |
if (defined $key and defined $keyvar and is_variable($keyvar)) |
|
5313
|
17 |
0 |
if (is_int_index($k)) { } |
|
5320
|
23 |
0 |
if (defined $valvar and is_variable($valvar)) |
|
5325
|
0 |
23 |
unless (defined $res) |
|
5333
|
2 |
0 |
if (defined $u or defined $f and !defined($r) || $f ne $r) |
|
5334
|
2 |
0 |
defined $f ? : |
|
5338
|
0 |
21 |
if (defined $r) |
|
5339
|
0 |
0 |
if $ctx->{'log'} |
|
5345
|
0 |
21 |
if (defined $fin) |
|
5353
|
9 |
8 |
if (defined $key and defined $keyvar and $keyvar ne $key) |
|
5355
|
9 |
0 |
defined $_basevar2 ? : |
|
5357
|
11 |
10 |
if (defined $valvar and $valvar ne $value) |
|
5359
|
11 |
0 |
defined $_basevar ? : |
|
5364
|
0 |
8 |
if $ctx->{'log'} |
|
5368
|
9 |
10 |
if (defined $res) |
|
5372
|
0 |
9 |
if (defined $fin) |
|
5379
|
6 |
3 |
if (scalar @seq > 1) { } |
|
|
3 |
0 |
elsif (scalar @seq > 0) { } |
|
5384
|
0 |
9 |
if $ctx->{'log'} |
|
5389
|
10 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
5390
|
0 |
10 |
if $ctx->{'log'} |
|
5399
|
4 |
6 |
if ($expr ne $expr0) |
|
5413
|
0 |
1 |
if ($expr ne $expr0 or $block ne $block0 or defined $valvar and $value ne $valvar or defined $key and defined $keyvar and $key ne $keyvar) |
|
5417
|
0 |
8 |
if $ctx->{'log'} |
|
5430
|
3 |
6 |
if (is_strval($op1)) |
|
5434
|
0 |
3 |
if defined $fin |
|
5440
|
5 |
0 |
if (defined $c) |
|
5442
|
5 |
0 |
if (is_strval($op2)) { } |
|
5444
|
3 |
2 |
if (defined $result and $result) |
|
5455
|
0 |
3 |
unless (defined $found) |
|
5461
|
0 |
0 |
unless (defined $c) |
|
5467
|
3 |
0 |
if (defined $found and $found >= 0) |
|
5472
|
0 |
4 |
unless (defined $res) |
|
5477
|
1 |
3 |
if (defined $f) |
|
5482
|
1 |
3 |
if (defined $f) |
|
5489
|
0 |
3 |
if (scalar @seq > 1) { } |
|
|
3 |
0 |
elsif (scalar @seq > 0) { } |
|
5500
|
6 |
0 |
if (exists $ctx->{'simplify'}{'stmt'}) |
|
5501
|
0 |
6 |
if $ctx->{'log'} |
|
5508
|
0 |
6 |
if ($expr ne $op1) |
|
5529
|
8 |
0 |
if (defined $c) |
|
5534
|
2 |
6 |
if (defined $c0 and $c0 ne $c or $b0 ne $b) |
|
5543
|
2 |
4 |
if ($expr ne $op1 or $changed) |
|
5545
|
0 |
2 |
if $ctx->{'log'} |
|
5549
|
0 |
4 |
if (defined $fin) |
|
5553
|
0 |
0 |
if (scalar @seq > 1) { } |
|
|
0 |
0 |
elsif (scalar @seq > 0) { } |
|
5569
|
47 |
169 |
exists $ctx->{'class_scope'} ? : |
|
|
216 |
26 |
defined $f ? : |
|
5574
|
106 |
136 |
if (scalar @$a > 0) |
|
5576
|
107 |
4 |
if (is_variable($v)) { } |
|
|
2 |
2 |
elsif ($v =~ /^#expr\d+$/) { } |
|
|
2 |
0 |
elsif ($v =~ /^#ref\d+$/) { } |
|
5580
|
2 |
0 |
if ($op eq "=" and is_variable($v1)) |
|
5585
|
2 |
0 |
if (is_variable($r)) |
|
5593
|
2 |
240 |
unless (is_block($b2)) |
|
5602
|
0 |
2 |
if $ctx->{'log'} |
|
5605
|
70 |
172 |
if ($b2 ne $b) |
|
5607
|
69 |
1 |
if (defined $f) |
|
5612
|
18 |
154 |
if (defined $f and not $ctx->getfun($f)) |
|
5615
|
0 |
18 |
if $ctx->{'log'} |
|
5621
|
56 |
0 |
defined $c ? : |
|
5631
|
47 |
47 |
if ($a =~ /^#fun\d+$/) { } |
|
|
9 |
38 |
elsif ($a =~ /^#expr\d+$/) { } |
|
|
13 |
25 |
elsif ($a =~ /^#stmt\d+$/) { } |
|
5636
|
16 |
31 |
if ($f ne $a) |
|
5642
|
9 |
0 |
if ($op eq "=") |
|
5649
|
9 |
4 |
if ($cmd eq 'static') { } |
|
|
4 |
0 |
elsif ($cmd eq 'const') { } |
|
5660
|
13 |
43 |
if ($changed) |
|
5666
|
2 |
41 |
if (defined $c and not $ctx->getclass($c)) |
|
5667
|
0 |
2 |
if $ctx->{'log'} |
|
5694
|
0 |
2 |
if (scalar keys %{$$ctx{"varhist"};} > 0) |
|
5704
|
395 |
2663 |
if (scalar keys %{$$ctx{"varhist"};} > 0) |
|
5710
|
0 |
0 |
defined $stmt ? : |
|
|
0 |
417 |
if $ctx->{'log'} |
|
5712
|
305 |
112 |
if ($ctx->{'varhist'}{$v}[0] ne "#unresolved") |
|
5714
|
218 |
87 |
if ($v =~ /^\$eval\$/) { } |
|
5718
|
157 |
61 |
if (is_block($e)) { } |
|
5731
|
193 |
202 |
if (scalar @ass > 0 or scalar @blk > 0) |
|
5732
|
165 |
28 |
if (defined $stmt) |