| line | true | false | branch | 
 
| 318 | 40 | 5639 | unless (defined $tag) | 
 
| 325 | 218 | 5421 | if (ref $value) | 
 
| 326 | 78 | 140 | if (ref $value eq 'ARRAY') { } | 
 
|  | 127 | 13 | elsif (ref $value eq 'SCALAR') { } | 
 
| 329 | 51 | 27 | if (@$value > 1) { } | 
 
| 334 | 2 | 151 | if ref $_ | 
 
| 336 | 21 | 132 | if $e | 
 
| 340 | 1 | 50 | if $noJoin | 
 
| 347 | 0 | 27 | if ref $value eq "SCALAR" | 
 
| 355 | 5327 | 29 | if defined $value and not ref $value and not $options{'Sanitized'} | 
 
| 358 | 533 | 5105 | if $tag =~ /(.*):(.+)/ | 
 
| 361 | 4 | 5634 | if $tag =~ s/#$// | 
 
| 365 | 5135 | 503 | if $convType eq "PrintConv" | 
 
| 369 | 2414 | 3224 | if ($wantGroup) | 
 
| 371 | 0 | 2440 | unless length $_ and /^(\d+)?(.*)/ | 
 
| 375 | 2331 | 109 | unless $lcg eq "*" or $lcg eq "all" | 
 
| 376 | 1 | 2439 | if ($g =~ s/^ID-//i) { } | 
 
|  | 30 | 2409 | elsif (defined $f) { } | 
 
| 377 | 0 | 1 | if defined $f and $f ne 7 | 
 
| 380 | 0 | 30 | if $f > 2 | 
 
| 381 | 9 | 21 | if $f == 2 | 
 
| 383 | 94 | 2315 | if $family2groups{$lcg} | 
 
| 386 | 109 | 2305 | unless @wantGroup | 
 
| 390 | 37 | 5601 | if lc $tag eq "all" | 
 
| 398 | 34 | 13 | if ($wantGroup) { } | 
 
| 399 | 34 | 0 | unless $wantGroup =~ /^XM[LP]-\*$/i | 
 
| 401 | 4 | 30 | if (@del and $remove) | 
 
| 403 | 2 | 2 | if $excludeGroups{$del[0]} | 
 
| 409 | 0 | 10 | if (ref $parent) | 
 
| 413 | 4 | 6 | unless $dirName = $parent || shift @dirNames | 
 
| 419 | 7 | 27 | if $wantGroup =~ /^(MIE\d+|XM[LP]-[-\w]*\w)$/i | 
 
| 424 | 47 | 0 | if (@del) { } | 
 
|  | 0 | 0 | elsif (grep /^$wantGroup$/i, @delGroup2) { } | 
 
| 429 | 23 | 781 | if ($remove) { } | 
 
| 431 | 4 | 19 | if ($grp =~ /^(XM[LP])(-.*)?$/) | 
 
| 433 | 1 | 3 | if ($grp eq $x) { } | 
 
|  | 3 | 0 | elsif ($$delGroup{"$x-*"} and not $$delGroup{"-$grp"}) { } | 
 
| 436 | 57 | 1 | unless /^(-?)$x-/ | 
 
| 437 | 1 | 0 | unless $1 | 
 
| 442 | 2 | 1 | if ($delGroup->{$x}) | 
 
| 451 | 15 | 8 | if (exists $delGroup->{$grp}) { } | 
 
| 454 | 5 | 3 | unless $didExcl | 
 
| 459 | 49 | 732 | if ($delMore{$grp}) | 
 
| 467 | 1 | 46 | if ($verbose > 1 and @donegrps) | 
 
| 469 | 0 | 1 | $remove ? : | 
 
| 478 | 0 | 47 | if wantarray | 
 
| 479 | 0 | 47 | if $err | 
 
| 488 | 27 | 5564 | if ($writeMode ne "wcg") | 
 
| 489 | 25 | 2 | unless $writeMode =~ /w/i | 
 
| 490 | 2 | 25 | if (not $writeMode =~ /c/i) { } | 
 
|  | 8 | 17 | elsif (not $writeMode =~ /g/i) { } | 
 
| 491 | 0 | 2 | if $createOnly | 
 
| 500 | 19 | 2278 | if defined $fg->[0] and $fg->[0] != 1 | 
 
| 504 | 131 | 2147 | if (/^IFD(\d+)$/i) { } | 
 
|  | 0 | 2147 | elsif (/^SubIFD(\d+)$/i) { } | 
 
|  | 0 | 2147 | elsif (/^Version(\d+)$/i) { } | 
 
|  | 274 | 1873 | elsif ($exifDirs{$_}) { } | 
 
|  | 293 | 1580 | elsif ($allFam0{$_}) { } | 
 
|  | 1 | 1579 | elsif (/^Track(\d+)$/i) { } | 
 
|  | 2 | 1577 | elsif (/^MIE(\d*-?)(\w+)$/i) { } | 
 
|  | 502 | 1081 | elsif (not $ifdName and /^XMP\b/i) { } | 
 
| 512 | 274 | 0 | unless $ifdName and $allFam0{$_} | 
 
| 523 | 502 | 0 | if ($writeProc) | 
 
| 529 | 701 | 1577 | if $grpName and $grpName ne $_ | 
 
| 539 | 51 | 1365 | if ($tag =~ /^([?*\w]+)-([a-z]{2})(_[a-z]{2})$/i or $tag =~ /^([?*\w]+)-([a-z]{2,3}|[xi])(-[a-z\d]{2,8}(-[a-z\d]{1,8})*)?$/i) { } | 
 
|  | 1365 | 0 | elsif (not $options{'NoShortcut'}) { } | 
 
| 545 | 18 | 3 | length $3 == 3 ? : | 
 
|  | 21 | 30 | if $3 | 
 
| 549 | 0 | 238 | unless $tagInfo->{'Table'} | 
 
| 550 | 52 | 186 | unless my $langInfoProc = $tagInfo->{'Table'}{'LANG_INFO'} | 
 
| 552 | 168 | 18 | if $langInfo | 
 
| 554 | 49 | 2 | if @matchingTags | 
 
| 560 | 1 | 1364 | if ($match) | 
 
| 565 | 0 | 3 | if $e | 
 
| 567 | 1 | 0 | if $numSet | 
 
| 568 | 0 | 1 | if wantarray | 
 
| 569 | 0 | 1 | if $err | 
 
| 573 | 1366 | 0 | unless ($listOnly) | 
 
| 574 | 49 | 1317 | if (not &TagExists($tag)) { } | 
 
|  | 0 | 1317 | elsif ($langCode) { } | 
 
|  | 507 | 810 | elsif ($wantGroup) { } | 
 
| 575 | 49 | 0 | if ($tag =~ /^[-\w*?]+$/) { } | 
 
| 576 | 29 | 20 | $wantGroup ? : | 
 
| 578 | 2 | 47 | if $origTag =~ /-/ | 
 
| 579 | 0 | 49 | if (not $pre and uc $origTag eq "TAG") | 
 
| 584 | 0 | 0 | if $tag =~ /^\$/ | 
 
| 593 | 0 | 1366 | if $verbose > 2 | 
 
| 596 | 1366 | 0 | if wantarray | 
 
| 597 | 0 | 0 | if $err | 
 
| 613 | 24293 | 45620 | unless defined $highestPriority{$lcTag} | 
 
| 615 | 836 | 69077 | defined $tagInfo->{'Preferred'} ? : | 
 
| 616 | 49702 | 20211 | if ($wantGroup) | 
 
| 623 | 226 | 49514 | if $translateWantGroup{$lcWant} | 
 
| 626 | 2064 | 47676 | if $prfTag | 
 
| 627 | 49498 | 242 | if (not defined $fam) { } | 
 
|  | 2 | 240 | elsif ($fam == 7) { } | 
 
|  | 132 | 216 | elsif ($fam != 1 and not $tagInfo->{'AllowGroup'}) { } | 
 
| 628 | 2182 | 47316 | if ($lcWant eq lc $grp[0]) | 
 
| 631 | 4 | 2178 | if $wgAll and not $writeGroup | 
 
| 634 | 10577 | 36739 | if $lcWant eq lc $grp[2] | 
 
| 636 | 1 | 1 | if &IsSameID($tagInfo->{'TagID'}, $lcWant) | 
 
| 638 | 22 | 110 | if $lcWant eq lc $grp[$fam] | 
 
| 639 | 5 | 10 | if ($wgAll and not $fam and $allFam0{$lcWant}) | 
 
| 640 | 3 | 2 | unless $writeGroup | 
 
| 646 | 1581 | 35267 | if ($grp[0] eq 'EXIF' or $grp[0] eq 'SonyIDC' or $wgAll) { } | 
 
|  | 1558 | 33709 | elsif ($grp[0] eq 'QuickTime') { } | 
 
|  | 746 | 32963 | elsif ($grp[0] eq 'MIE') { } | 
 
|  | 32962 | 1 | elsif (not $tagInfo->{'AllowGroup'} && $lcWant =~ /^$tagInfo->{'AllowGroup'}$/i) { } | 
 
| 647 | 1141 | 440 | unless ($ifdName and $lcWant eq lc $ifdName) | 
 
| 648 | 37 | 7 | unless $wgAll and not $fam and $allFam0{$lcWant} | 
 
| 649 | 2 | 5 | unless $writeGroup | 
 
| 652 | 2 | 47 | if $wgAll and $allFam0{$lcWant} and $fam | 
 
| 654 | 0 | 438 | if $lcWant eq "PreviewIFD" | 
 
| 657 | 16 | 1542 | if ($grp[1] eq 'Track#') { } | 
 
| 658 | 15 | 1 | unless $movGroup and $lcWant eq lc $movGroup | 
 
| 662 | 1514 | 28 | unless $grp and $lcWant eq lc $grp | 
 
| 666 | 744 | 2 | unless $mieGroup and $lcWant eq lc $mieGroup | 
 
| 669 | 0 | 0 | if ($writeGroup =~ /^MIE\d+$/ and $tagInfo->{'Table'}{'WRITE_GROUP'}) | 
 
| 675 | 32438 | 524 | unless $lcWant eq lc $grp[1] | 
 
| 678 | 13283 | 467 | unless $writeGroup | 
 
| 687 | 9 | 33952 | if ($table->{'SRC_TABLE'}) | 
 
| 689 | 0 | 9 | unless $writeProc | 
 
| 693 | 119 | 33842 | unless $writeProc and &$writeProc() | 
 
| 698 | 0 | 21052 | unless $writable or $table->{'WRITABLE'} and not defined $writable and not $tagInfo->{'SubDirectory'} | 
 
| 700 | 20287 | 3 | if (not $writeGroup or $translateWriteGroup{$writeGroup} and !$tagInfo->{'WriteGroup'} || $tagInfo->{'WriteGroup'} ne 'All') | 
 
| 707 | 16485 | 3802 | unless $writeGroup | 
 
| 709 | 20210 | 77 | unless ($priority) | 
 
| 710 | 22 | 20188 | if ($tagInfo->{'Avoid'} and $tagInfo->{'WriteAlso'}) { } | 
 
| 714 | 3568 | 16620 | unless ($priority) | 
 
| 720 | 1138 | 19149 | if $prfTag | 
 
| 724 | 31 | 33929 | if $noFlat and defined $tagInfo->{'Flat'} | 
 
| 725 | 2341 | 31619 | if ($prot) | 
 
| 727 | 1208 | 1133 | if ($prot) | 
 
| 730 | 1 | 1207 | if ($verbose > 1) | 
 
| 741 | 422 | 287 | if $table->{'GROUPS'}{'0'} eq "QuickTime" and !defined($highestQT{$lcTag}) || $highestQT{$lcTag} < $priority | 
 
| 742 | 10388 | 22364 | if ($priority > $highestPriority{$lcTag}) { } | 
 
|  | 13490 | 8874 | elsif ($priority == $highestPriority{$lcTag}) { } | 
 
| 745 | 1259 | 9129 | $tagInfo->{'Avoid'} ? : | 
 
| 749 | 330 | 13160 | if $tagInfo->{'Avoid'} | 
 
| 751 | 111 | 32641 | if ($tagInfo->{'WriteAlso'}) { } | 
 
| 758 | 5490 | 27262 | if ($writeGroup eq "XMP") | 
 
| 760 | 0 | 5490 | if $wg | 
 
| 768 | 111 | 4113 | if @writeAlsoList | 
 
| 774 | 9 | 9526 | if ($preferred{$lcTag} and $highestPriority{$lcTag} == 0 and %{$self->{'WRITE_PRIORITY'};}) | 
 
| 780 | 1350 | 0 | if ($avoid{$lcTag} and $preferred{$lcTag}) | 
 
| 781 | 1236 | 114 | if ($avoid{$lcTag} < scalar keys %{$preferred{$lcTag};}) { } | 
 
|  | 29 | 85 | elsif ($highestPriority{$lcTag} < 1000) { } | 
 
| 784 | 4555308 | 5803 | unless $lcTag eq lc $tagInfo->{'Name'} | 
 
| 785 | 1534 | 4269 | if $tagInfo->{'Avoid'} | 
 
| 792 | 10860 | 102 | unless $lcTag eq lc $tagInfo->{'Name'} | 
 
| 793 | 1 | 101 | unless my $priority = $tagPriority{$tagInfo} | 
 
| 794 | 30 | 71 | if $priority == $highestPriority{$lcTag} | 
 
| 795 | 0 | 71 | if $priority < $nextHighest | 
 
| 797 | 71 | 0 | unless defined $permanent | 
 
| 798 | 4 | 67 | if $tagInfo->{'Avoid'} or $permanent | 
 
| 799 | 44 | 23 | if $writeGroup{$tagInfo} eq "MakerNotes" | 
 
| 800 | 18 | 5 | if ($nextHighest < $priority) | 
 
| 806 | 13 | 16 | if (@nextBestTags) | 
 
| 825 | 9 | 32731 | if $alsoWrote{$tagInfo} | 
 
| 827 | 221 | 32510 | if defined $listOnly and ($listOnly xor $tagInfo->{'List'}) | 
 
| 831 | 31904 | 606 | unless defined $permanent | 
 
| 832 | 31903 | 607 | unless defined $permanent | 
 
| 838 | 22 | 1959 | if not $pref->{$tagInfo} and $tagInfo->{'Avoid'} and $tagInfo->{'WriteAlso'} | 
 
| 841 | 164 | 32324 | if (defined $shift) | 
 
| 844 | 0 | 164 | if ($tagInfo->{'List'}) { } | 
 
| 848 | 24 | 140 | unless ($shift) | 
 
| 850 | 24 | 0 | if $addValue | 
 
| 853 | 0 | 0 | if $options{'DelValue'} and defined $shiftable and $shiftable eq "Time" | 
 
| 855 | 0 | 164 | if ($shift and not defined $value && length $value) | 
 
| 864 | 0 | 0 | if (defined $shiftable and not $shiftable and $shift || $shiftable eq '0' && $options{'DelValue'}) | 
 
| 869 | 0 | 0 | if $verbose | 
 
| 874 | 21666 | 10822 | if (defined $val) { } | 
 
|  | 6784 | 4038 | elsif ($permanent) { } | 
 
|  | 0 | 4038 | elsif ($addValue or $options{'DelValue'}) { } | 
 
| 876 | 9 | 21657 | if ($addValue and not $shift || $tagInfo->{'List'}) | 
 
| 877 | 0 | 9 | if ($addValue eq '2') { } | 
 
| 881 | 0 | 9 | if $verbose > 2 | 
 
| 885 | 164 | 21493 | if ($shift) { } | 
 
|  | 35 | 21458 | elsif (not length $val and $options{'DelValue'}) { } | 
 
|  | 2 | 42890 | elsif (ref $val eq 'HASH' and not $tagInfo->{'Struct'}) { } | 
 
| 886 | 47 | 117 | if ($tagInfo->{'Shift'} and $tagInfo->{'Shift'} eq 'Time') { } | 
 
|  | 113 | 4 | elsif (&IsFloat($val)) { } | 
 
| 888 | 17 | 30 | $shift > 0 ? : | 
 
| 892 | 0 | 47 | if ($err2) | 
 
| 894 | 0 | 0 | if $verbose > 2 | 
 
| 901 | 0 | 4 | if $verbose > 2 | 
 
| 909 | 0 | 2 | if $verbose > 2 | 
 
| 913 | 4 | 6780 | if $options{'IgnorePermanent'} | 
 
| 915 | 33 | 6747 | if (defined $tagInfo->{'DelValue'}) { } | 
 
| 923 | 0 | 0 | if $verbose > 2 | 
 
| 926 | 6 | 4032 | if ($tagInfo->{'DelCheck'}) | 
 
| 929 | 0 | 6 | if $@ | 
 
| 930 | 6 | 0 | if (defined $err2) | 
 
| 932 | 3 | 3 | unless $err2 | 
 
| 933 | 0 | 3 | unless $err2 =~ /delete$/ | 
 
| 935 | 0 | 3 | if $verbose > 2 | 
 
| 940 | 3 | 4029 | if ($tagInfo->{'DelGroup'} and not $options{'DelValue'}) | 
 
| 944 | 0 | 3 | if ($delMore{$tag}) | 
 
| 949 | 0 | 3 | if $verbose | 
 
| 957 | 28203 | 4257 | unless ($noConv) | 
 
| 962 | 8476 | 19727 | if (defined $e) | 
 
| 964 | 17 | 8459 | unless $e | 
 
| 968 | 2805 | 29638 | if (not defined $val and defined $value) | 
 
| 971 | 2805 | 0 | unless $options{'DelValue'} | 
 
| 974 | 214 | 29424 | unless $self->{'NEW_VALUE'} | 
 
| 975 | 14215 | 15423 | if ($options{'Replace'}) | 
 
| 979 | 25 | 14190 | if ($tagInfo->{'WriteAlso'}) | 
 
| 982 | 6 | 19 | if ($tagInfo->{'WriteGroup'} and $tagInfo->{'WriteGroup'} eq 'All' and $writeGroup) { } | 
 
| 993 | 274 | 13941 | if $options{'Replace'} == 2 | 
 
| 996 | 19885 | 9479 | if (defined $val) { } | 
 
|  | 5556 | 3923 | elsif ($permanent) { } | 
 
|  | 0 | 3923 | elsif ($addValue or $options{'DelValue'}) { } | 
 
| 1001 | 0 | 19885 | unless $nvHash | 
 
| 1002 | 314 | 19571 | if $tagInfo->{'List'} and not $options{'Replace'} | 
 
| 1004 | 66 | 19819 | if $editOnly | 
 
| 1006 | 22 | 19863 | if ($tagInfo->{'MakerNotes'}) | 
 
| 1009 | 49 | 19836 | if ($createOnly) { } | 
 
|  | 227 | 19609 | elsif ($options{'DelValue'} or $addValue or $shift) { } | 
 
| 1015 | 225 | 2 | unless $nvHash->{'DelValue'} | 
 
| 1016 | 160 | 67 | if ($shift) { } | 
 
|  | 54 | 13 | elsif ($options{'DelValue'}) { } | 
 
| 1021 | 8 | 11 | unless $val eq "" or $tagInfo->{'List'} | 
 
| 1023 | 2 | 52 | ref $val eq 'ARRAY' ? : | 
 
| 1024 | 0 | 54 | if ($verbose > 1) | 
 
| 1025 | 0 | 0 | $permanent ? : | 
 
| 1026 | 0 | 0 | $tagInfo->{'List'} ? : | 
 
| 1027 | 0 | 0 | ref $val eq 'ARRAY' ? : | 
 
| 1029 | 0 | 0 | if (ref $_ eq "HASH") | 
 
| 1041 | 276 | 19609 | defined $tagInfo->{'Preferred'} ? : | 
 
| 1043 | 660 | 19225 | if ($tagInfo->{'Table'}{'GROUPS'}{'0'} eq "QuickTime") | 
 
| 1044 | 367 | 293 | if $tagPriority{$tagInfo} < $highestQT{$lcTag} | 
 
| 1046 | 9209 | 10676 | if ($pref->{$tagInfo} or $prf) | 
 
| 1047 | 5447 | 3762 | if ($permanent or $shift) { } | 
 
|  | 3748 | 14 | elsif ($tagInfo->{'List'} and not $options{'DelValue'} or not $nvHash->{'DelValue'} && @{$nvHash->{'DelValue'};} or grep /^$/, @{$$nvHash{'DelValue'};}) { } | 
 
| 1056 | 19 | 3717 | $editGroup ? : | 
 
|  | 12 | 3736 | $editOnly ? : | 
 
| 1058 | 2479 | 1269 | unless $createGroups | 
 
| 1063 | 3738 | 16147 | if ($nvHash->{'IsCreating'}) { } | 
 
|  | 22 | 16125 | elsif ($createOnly) { } | 
 
| 1064 | 227 | 3511 | if (%{$self->{'DEL_GROUP'};}) | 
 
| 1067 | 12235 | 354 | if $self->{'DEL_GROUP'}{$grp} == 2 | 
 
| 1072 | 1 | 226 | if ($verbose > 1 and @grps) | 
 
| 1078 | 9 | 5 | $tagInfo->{'Avoid'} ? : | 
 
|  | 8 | 14 | $permanent ? : | 
 
| 1079 | 0 | 5 | $shift ? : | 
 
|  | 5 | 17 | unless $noCreate | 
 
| 1080 | 0 | 22 | if $verbose > 2 | 
 
| 1083 | 19809 | 54 | if ($shift or not $options{'DelValue'}) | 
 
| 1084 | 19269 | 540 | unless $nvHash->{'Value'} | 
 
| 1085 | 19293 | 516 | if (not $tagInfo->{'List'}) { } | 
 
|  | 0 | 516 | elsif (defined $nvHash->{'AddBefore'} and @{$nvHash->{'Value'};} >= $nvHash->{'AddBefore'}) { } | 
 
| 1091 | 0 | 0 | ref $val eq 'ARRAY' ? : | 
 
| 1094 | 44 | 472 | ref $val eq 'ARRAY' ? : | 
 
| 1096 | 22 | 19787 | if ($verbose > 1) | 
 
| 1098 | 0 | 22 | if ($tagInfo->{'IsComposite'}) { } | 
 
| 1100 | 0 | 0 | if ($tagInfo->{'WriteAlso'}) { } | 
 
| 1111 | 0 | 0 | $nvHash->{'IsCreating'} == 2 ? : | 
 
|  | 0 | 15 | $nvHash->{'IsCreating'} == 2 ? : | 
 
|  | 0 | 15 | $createOnly ? : | 
 
|  | 0 | 7 | $nvHash->{'DelValue'} && @{$nvHash->{'DelValue'};} ? : | 
 
|  | 15 | 7 | $nvHash->{'IsCreating'} ? : | 
 
| 1114 | 0 | 22 | $addValue ? : | 
 
|  | 0 | 22 | $shift ? : | 
 
| 1120 | 0 | 5556 | if $verbose > 1 | 
 
| 1123 | 0 | 0 | if $verbose > 1 | 
 
| 1130 | 0 | 3923 | if $verbose > 1 | 
 
| 1132 | 1423 | 22363 | if $setTags | 
 
| 1133 | 11109 | 12677 | if $pref->{$tagInfo} | 
 
| 1138 | 76 | 23730 | if ($writeAlso) | 
 
| 1141 | 46 | 30 | if ($tagInfo->{'WriteGroup'} and $tagInfo->{'WriteGroup'} eq 'All' and $writeGroup) { } | 
 
| 1163 | 7 | 236 | unless defined $val | 
 
| 1164 | 0 | 243 | if $@ | 
 
| 1165 | 243 | 0 | unless ($Image::ExifTool::evalWarning) | 
 
| 1169 | 148 | 84 | if $n and $pref->{$tagInfo} | 
 
| 1171 | 9 | 2 | if ($Image::ExifTool::evalWarning and !$err || $verbose > 2) | 
 
| 1173 | 9 | 0 | if ($str) | 
 
| 1174 | 9 | 0 | unless $str =~ / for [-\w:]+$/ | 
 
| 1176 | 9 | 0 | unless $err | 
 
| 1177 | 0 | 9 | if $verbose > 2 | 
 
| 1185 | 85 | 4135 | if (defined $err and not $prioritySet) { } | 
 
|  | 619 | 3516 | elsif (not $numSet) { } | 
 
|  | 0 | 3516 | elsif ($self->{'CHECK_WARN'}) { } | 
 
|  | 437 | 6158 | elsif ($err and not $verbose) { } | 
 
| 1186 | 0 | 85 | if $err and not wantarray | 
 
| 1188 | 420 | 199 | $wantGroup ? : | 
 
| 1189 | 372 | 247 | if ($wasProtected) { } | 
 
|  | 240 | 7 | elsif (not $listOnly) { } | 
 
| 1191 | 360 | 12 | unless ($options{'Replace'} and $options{'Replace'} == 2) | 
 
| 1195 | 0 | 240 | if ($origTag =~ /[?*]/) { } | 
 
|  | 0 | 240 | elsif ($noCreate) { } | 
 
|  | 0 | 240 | elsif ($foundMatch) { } | 
 
|  | 240 | 0 | elsif ($wantGroup and @matchingTags) { } | 
 
| 1196 | 0 | 0 | if ($noCreate) { } | 
 
|  | 0 | 0 | elsif ($foundMatch) { } | 
 
| 1215 | 600 | 19 | if ($err) | 
 
| 1216 | 0 | 600 | if $verbose > 2 | 
 
| 1217 | 0 | 600 | unless wantarray | 
 
| 1221 | 0 | 0 | if $verbose > 2 | 
 
| 1225 | 3797 | 423 | if wantarray | 
 
| 1257 | 44 | 15 | if @setTags | 
 
| 1266 | 0 | 59 | defined $options->{'Struct'} ? : | 
 
| 1268 | 15 | 44 | if $structOpt eq 2 and not @setTags | 
 
| 1322 | 0 | 59 | $options->{'FastScan'} && $options->{'FastScan'} > 1 ? : | 
 
|  | 0 | 59 | defined $options->{'StrictDate'} ? : | 
 
| 1326 | 1 | 68 | if ref $tag | 
 
| 1327 | 7 | 61 | if ($tag =~ /^-(.*)/) | 
 
| 1334 | 30 | 31 | if (/(.+?)\s*(>|<)\s*(.+)/) | 
 
| 1335 | 10 | 20 | if ($2 eq '>') { } | 
 
| 1339 | 7 | 13 | if /\$/ | 
 
| 1342 | 54 | 0 | if /(^|:)([-\w?*]+)#?$/ | 
 
| 1344 | 6 | 53 | if (@exclude) | 
 
| 1348 | 43 | 16 | if @reqTags | 
 
| 1350 | 0 | 59 | if ($opts{'Type'}) | 
 
| 1354 | 0 | 0 | $opts{'Type'} eq 'PrintConv' ? : | 
 
| 1357 | 55 | 4 | $printConv ? : | 
 
| 1361 | 0 | 59 | if $info->{'Error'} and $info->{'Error'} eq "Error opening file" | 
 
| 1369 | 15 | 44 | unless (@setTags) | 
 
| 1375 | 4 | 2645 | if $tag =~ /^(Error|Warning)\b/ | 
 
| 1377 | 0 | 2645 | if ($opts{'SrcType'} and $opts{'SrcType'} ne $srcType) | 
 
| 1383 | 986 | 1659 | unless $n | 
 
| 1393 | 1 | 68 | if (ref $t eq "HASH") | 
 
| 1406 | 30 | 38 | if ($tag =~ /(.+?)\s*(>|<)\s*(.+)/) { } | 
 
| 1409 | 10 | 20 | if ($2 eq '>') { } | 
 
| 1412 | 0 | 10 | if $tag =~ s/\s*([-+])$// or $dstTag =~ s/^([-+])\s*// | 
 
| 1415 | 0 | 20 | if $dstTag =~ s/\s*([-+])$// | 
 
| 1417 | 7 | 13 | if ($tag =~ /\$/) { } | 
 
| 1425 | 0 | 13 | if $tag =~ s/^([-+])\s*// | 
 
| 1428 | 3 | 27 | if $dstTag =~ s/^\+// | 
 
| 1430 | 0 | 30 | unless ($opts->{'EXPR'} or &ValidTagName($tag)) | 
 
| 1434 | 0 | 30 | unless &ValidTagName($dstTag) | 
 
| 1436 | 0 | 30 | if ($opt) | 
 
| 1440 | 16 | 14 | if $dstTag =~ /(.*):(.+)/ | 
 
| 1442 | 0 | 30 | if $dstTag =~ s/#$// | 
 
| 1444 | 3 | 27 | if $dstTag eq "all" | 
 
| 1446 | 0 | 38 | if $tag =~ s/^\+// | 
 
| 1448 | 61 | 7 | unless ($opts->{'EXPR'}) | 
 
| 1450 | 34 | 27 | if ($tag =~ /(.*):(.+)/) | 
 
| 1454 | 0 | 35 | unless length $_ and /^(\d+)?(.*)/ | 
 
| 1456 | 0 | 35 | if !$f || $f eq '7' and $g =~ s/^ID-//i | 
 
| 1457 | 3 | 0 | if ($g =~ /^file\d+$/i and !$f || $f eq '8') | 
 
| 1460 | 3 | 0 | if ($srcExifTool->{'ALT_EXIFTOOL'}{$g8}) | 
 
| 1462 | 1 | 2 | unless $altFiles{$g8} | 
 
| 1467 | 26 | 9 | unless $g eq "*" or $g eq "all" | 
 
| 1471 | 0 | 61 | if ($tag =~ s/#$//) | 
 
| 1473 | 0 | 0 | unless $dstTag | 
 
| 1476 | 14 | 47 | if $tag eq "all" | 
 
| 1478 | 3 | 58 | if ($tag =~ /[?*]/ and $tag ne "*") | 
 
| 1485 | 30 | 38 | if ($dstTag) { } | 
 
|  | 7 | 31 | elsif ($isExclude) { } | 
 
| 1487 | 0 | 30 | if $isExclude | 
 
| 1495 | 1 | 6 | unless @setList | 
 
| 1498 | 1 | 30 | $opts->{'WILD'} ? : | 
 
| 1509 | 1 | 0 | if (%$altInfo) | 
 
| 1516 | 62 | 7 | if $set->[2] | 
 
| 1522 | 14 | 6473 | if ($tag =~ /^(Error|Warning)( |$)/) | 
 
| 1523 | 1 | 13 | if ($tag eq 'Warning DUMMY') { } | 
 
| 1535 | 967 | 9238 | if $opts->{'EXPR'} | 
 
| 1536 | 570 | 8668 | if $opts->{'GROUP8'} xor $isAlt | 
 
| 1538 | 6048 | 2620 | unless ($set->[1] eq $lcTag or $set->[1] eq "*") | 
 
| 1540 | 6032 | 16 | unless $opts->{'WILD'} and $lcTag =~ /^$set->[1]$/ | 
 
| 1543 | 1472 | 1164 | if (@{$set->[0];}) | 
 
| 1545 | 1368 | 104 | unless (@grp) | 
 
| 1551 | 1510 | 4 | if (not defined $f) { } | 
 
|  | 0 | 4 | elsif ($f == 7) { } | 
 
| 1552 | 1014 | 496 | unless $grp{$g} | 
 
| 1554 | 0 | 0 | unless &IsSameID(scalar $srcExifTool->GetTagID($tag), $g) | 
 
| 1556 | 0 | 4 | unless defined $grp[$f] and $g eq $grp[$f] | 
 
| 1560 | 174 | 1448 | unless $set->[2] | 
 
| 1570 | 7 | 62 | if ($opts->{'EXPR'}) | 
 
| 1572 | 0 | 7 | if ($srcExifTool->{'VALUE'}{'Error'}) | 
 
| 1577 | 0 | 0 | unless defined $val | 
 
| 1580 | 7 | 0 | unless $dstTag =~ /[?*]/ and $dstTag ne "*" | 
 
| 1581 | 0 | 7 | if $dstGrp | 
 
| 1583 | 7 | 0 | if $rtnVals[0] | 
 
| 1588 | 0 | 1448 | if ($opts->{'SrcType'} and $opts->{'SrcType'} ne $srcType) { } | 
 
| 1594 | 1366 | 82 | if ($dstGrp) { } | 
 
| 1599 | 286 | 1082 | unless /^(\d*)(all|\*)$/i | 
 
| 1600 | 0 | 1082 | length $1 ? : | 
 
| 1608 | 7 | 1441 | if ($srcExifTool->{'TAG_INFO'}{$tag}{'MakerNotes'}) | 
 
| 1612 | 1415 | 33 | if ($dstTag eq "*") | 
 
| 1616 | 1411 | 37 | if ($set->[1] eq '*' or $set->[3]{'WILD'}) { } | 
 
| 1619 | 26 | 118 | if $srcExifTool->{'TAG_INFO'}{$tag}{'Protected'} and $srcExifTool->{'TAG_INFO'}{$tag}{'Binary'} | 
 
| 1623 | 1385 | 0 | $structOpt eq '2' ? : | 
 
| 1626 | 37 | 0 | unless $dstTag =~ /[?*]/ | 
 
| 1636 | 0 | 1422 | if ($wrn and not $noWarn) | 
 
| 1641 | 666 | 756 | if $rtn | 
 
| 1662 | 4008 | 2727 | if (ref $tag eq 'HASH' and $tag->{'IsNVH'} or not defined $tag) { } | 
 
| 1666 | 2610 | 117 | if ($self->{'NEW_VALUE'}) | 
 
| 1668 | 50 | 2560 | if (ref $tag) { } | 
 
|  | 1477 | 1083 | elsif (defined($tagInfo = $Image::ExifTool::Extra{$tag}) and $tagInfo->{'Writable'}) { } | 
 
| 1677 | 5 | 1078 | if $tag =~ s/(.*):// | 
 
| 1681 | 1083 | 4 | unless my $nvh = $self->GetNewValueHash($tagInfo) | 
 
| 1684 | 0 | 2 | if $_ eq $nvh->{'WriteGroup'} | 
 
| 1686 | 0 | 2 | if ($grps[0] eq $nvh->{'WriteGroup'}) { } | 
 
| 1688 | 0 | 0 | if $_ eq $grps[1] | 
 
| 1691 | 2 | 0 | if $_ eq $grps[0] | 
 
| 1694 | 0 | 0 | if /^ID-(.*)/i and &IsSameID($tagInfo->{'TagID'}, $1) | 
 
| 1696 | 0 | 0 | unless $nvh = $nvh->{'Next'} | 
 
| 1700 | 2 | 2 | if defined $nvHash->{'IsCreating'} | 
 
| 1705 | 1826 | 901 | if $newValueHashPt | 
 
| 1707 | 4462 | 2273 | unless ($nvHash and $nvHash->{'Value'}) | 
 
| 1708 | 1787 | 2675 | if wantarray | 
 
| 1714 | 60 | 2213 | if ($nvHash->{'TagInfo'}{'RawConvInv'} or $nvHash->{'Shift'}) | 
 
| 1721 | 26 | 34 | if $nvHash->{'Shift'} and $table | 
 
| 1726 | 26 | 34 | if ($checkProc) { } | 
 
| 1728 | 0 | 26 | if ($err or not defined $val) | 
 
| 1729 | 0 | 0 | unless $err | 
 
| 1734 | 26 | 0 | unless $conv | 
 
| 1736 | 0 | 34 | unless $conv | 
 
| 1739 | 2 | 32 | if (ref $conv eq 'CODE') { } | 
 
| 1744 | 0 | 32 | if $@ | 
 
| 1746 | 0 | 34 | if ($Image::ExifTool::evalWarning) | 
 
| 1748 | 0 | 0 | if ($Image::ExifTool::evalWarning ne "\n") | 
 
| 1758 | 1114 | 1159 | if wantarray | 
 
| 1773 | 217 | 19 | if ($newVal) | 
 
| 1779 | 15 | 19124 | if $tagInfo->{'WriteNothing'} | 
 
| 1781 | 1 | 19123 | if $tagInfo->{'WritePseudo'} | 
 
| 1785 | 0 | 236 | unless wantarray | 
 
| 1804 | 115 | 0 | unless $nvHash->{'Save'} | 
 
| 1831 | 1 | 0 | if ($newValues) | 
 
| 1837 | 25 | 551 | if ($nvHash->{'Save'}) { } | 
 
| 1841 | 0 | 551 | if ($lastHash) { } | 
 
|  | 2 | 549 | elsif ($nvHash->{'Next'}) { } | 
 
| 1854 | 1 | 0 | if ($savedValues) | 
 
| 1855 | 0 | 1 | unless $newValues | 
 
| 1857 | 2 | 88 | if ($newValues->{$key}) { } | 
 
| 1881 | 0 | 6 | unless $g8 =~ /^File\d+$/ | 
 
| 1883 | 0 | 6 | if (not defined $file) { } | 
 
|  | 6 | 0 | elsif (not $self->{'ALT_EXIFTOOL'}{$g8} && $self->{'ALT_EXIFTOOL'}{$g8}{'ALT_FILE'} eq $file) { } | 
 
| 1905 | 0 | 0 | unless defined $tag | 
 
| 1907 | 0 | 0 | unless defined $val | 
 
| 1909 | 0 | 0 | unless $isOverwriting | 
 
| 1912 | 0 | 0 | if $tag eq "FileCreateDate" and $^O ne "MSWin32" | 
 
| 1913 | 0 | 0 | if ($isOverwriting < 0) | 
 
| 1915 | 0 | 0 | unless (defined $originalTime) | 
 
| 1917 | 0 | 0 | $tag eq 'FileCreateDate' ? : | 
 
| 1918 | 0 | 0 | unless defined $originalTime | 
 
| 1921 | 0 | 0 | unless $isUnixTime | 
 
| 1922 | 0 | 0 | unless $self->IsOverwriting($nvHash, $originalTime) | 
 
| 1926 | 0 | 0 | if ($tag eq 'FileCreateDate') { } | 
 
| 1927 | 0 | 0 | unless eval {
	do {
	require Win32::API
}
} | 
 
| 1928 | 0 | 0 | unless eval {
	do {
	require Win32API::File
}
} | 
 
| 1933 | 0 | 0 | unless $self->SetFileTime($file, $aTime, $mTime, $cTime, 1) | 
 
| 1955 | 1 | 0 | unless $opt | 
 
| 1957 | 1 | 0 | unless (defined $newName) | 
 
| 1958 | 0 | 1 | if ($opt) { } | 
 
| 1959 | 0 | 0 | if ($opt eq 'HardLink' or $opt eq 'Link') { } | 
 
|  | 0 | 0 | elsif ($opt eq 'SymLink') { } | 
 
|  | 0 | 0 | elsif ($opt eq 'Test') { } | 
 
| 1966 | 0 | 0 | unless defined $newName | 
 
| 1969 | 1 | 0 | if defined $filename and $self->IsOverwriting($nvHash, $file) | 
 
| 1971 | 0 | 1 | if defined $dir and $self->IsOverwriting($nvHash, $file) | 
 
| 1972 | 0 | 1 | unless $doName or $doDir | 
 
| 1973 | 1 | 0 | if ($doName) { } | 
 
| 1975 | 0 | 1 | if $doDir | 
 
| 1982 | 0 | 1 | if ($^O eq 'MSWin32') { } | 
 
| 1983 | 0 | 0 | if ($newName =~ /[\0-\x1f<>"|*]/) | 
 
| 1987 | 0 | 0 | if ($newName =~ /:/ and not $newName =~ /^[A-Z]:[^:]*$/i) | 
 
| 1991 | 0 | 0 | if ($newName =~ /\?/ and not $newName =~ m[^[\\/]{2}\?[\\/][^?]*$]) | 
 
| 1995 | 0 | 0 | if ($newName =~ m[(^|[\\/])(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.[^.]*)?$]i) | 
 
| 1999 | 0 | 0 | if ($newName =~ /([. ])$/) | 
 
| 2000 | 0 | 0 | if $self->Warn("New file name not recommended for Windows (ends with '$1')", 2) | 
 
| 2002 | 0 | 0 | if (length $newName > 259 and not $newName =~ /\?/) | 
 
| 2003 | 0 | 0 | if $self->Warn("New file name not recommended for Windows (exceeds 260 chars)", 2) | 
 
| 2009 | 0 | 1 | unless length $newName | 
 
| 2011 | 0 | 0 | if ($self->Exists($newName) and !defined($usedFlag) || $usedFlag) | 
 
| 2012 | 0 | 0 | if ($file ne $newName or $opt =~ /Link$/) { } | 
 
| 2014 | 0 | 0 | if ($opt =~ /Link$/ or not $self->IsSameFile($file, $newName)) | 
 
| 2023 | 0 | 1 | if ($opt eq "Test") | 
 
| 2030 | 0 | 1 | if (($result = $self->CreateDirectory($newName)) != 0) | 
 
| 2031 | 0 | 0 | if ($result < 0) | 
 
| 2037 | 0 | 1 | if ($opt eq 'HardLink' or $opt eq 'Link') { } | 
 
|  | 0 | 1 | elsif ($opt eq 'SymLink') { } | 
 
| 2038 | 0 | 0 | unless (link $file, $newName) | 
 
| 2046 | 0 | 0 | if $^O eq "MSWin32" | 
 
| 2051 | 0 | 0 | if (not $file =~ m[^/] and $newName =~ m[/]) | 
 
| 2052 | 0 | 0 | unless (eval {
	do {
	require Cwd
}
}) | 
 
| 2057 | 0 | 0 | unless (defined $file) | 
 
| 2062 | 0 | 0 | unless (eval {
	do {
	symlink $file, $newName
}
}) | 
 
| 2071 | 0 | 1 | unless ($self->Rename($file, $newName)) | 
 
| 2074 | 0 | 0 | unless ($self->Open(\*EXIFTOOL_SFN_IN, $file)) | 
 
| 2078 | 0 | 0 | unless ($self->Open(\*EXIFTOOL_SFN_OUT, $newName, ">")) | 
 
| 2087 | 0 | 0 | unless print EXIFTOOL_SFN_OUT $buff | 
 
| 2089 | 0 | 0 | unless close EXIFTOOL_SFN_OUT | 
 
| 2091 | 0 | 0 | if ($err) | 
 
| 2100 | 0 | 0 | unless $self->Unlink($file) | 
 
| 2119 | 0 | 223 | if (defined $perm) | 
 
| 2120 | 0 | 0 | if (eval {
	do {
	chmod $perm & 4095, $file
}
}) { } | 
 
| 2130 | 0 | 223 | if (defined $uid or defined $gid) | 
 
| 2131 | 0 | 0 | unless defined $uid | 
 
| 2132 | 0 | 0 | unless defined $gid | 
 
| 2133 | 0 | 0 | if (eval {
	do {
	chown $uid, $gid, $file
}
}) { } | 
 
| 2134 | 0 | 0 | if $uid >= 0 | 
 
| 2135 | 0 | 0 | if $gid >= 0 | 
 
| 2139 | 0 | 0 | unless $result | 
 
| 2146 | 1338 | 0 | unless $nvHash | 
 
| 2147 | 0 | 0 | if ($^O eq 'darwin') { } | 
 
|  | 0 | 0 | elsif ($tag ne 'FileCreateDate') { } | 
 
| 2148 | 0 | 0 | if ref $file | 
 
| 2151 | 0 | 0 | if $res == 1 or not $result | 
 
| 2160 | 0 | 223 | if ($zhash) | 
 
| 2162 | 0 | 0 | if ($^O ne 'MSWin32') { } | 
 
|  | 0 | 0 | elsif (ref $file) { } | 
 
|  | 0 | 0 | elsif (defined $self->GetNewValue('ZoneIdentifier', \$zhash)) { } | 
 
|  | 0 | 0 | elsif (not eval {
	do {
	require Win32API::File
}
}) { } | 
 
| 2173 | 0 | 0 | if ($self->EncodeFileName($zfile)) { } | 
 
| 2179 | 0 | 0 | if ($wattr == Win32API::File::INVALID_FILE_ATTRIBUTES()) { } | 
 
|  | 0 | 0 | elsif ($wattr & Win32API::File::FILE_ATTRIBUTE_READONLY()) { } | 
 
| 2184 | 0 | 0 | if ($wide) { } | 
 
| 2185 | 0 | 0 | if eval {
	do {
	Win32API::File::DeleteFileW($zfile)
}
} | 
 
| 2187 | 0 | 0 | if eval {
	do {
	Win32API::File::DeleteFile($zfile)
}
} | 
 
| 2189 | 0 | 0 | if ($res > 0) { } | 
 
| 2196 | 0 | 0 | if $res == 1 or not $result | 
 
| 2229 | 0 | 0 | if ($setModDate and $self->IsOverwriting($nvHash) < 0 and defined $infile and ref $infile ne "SCALAR") | 
 
| 2235 | 0 | 0 | if ($setCreateDate and $self->IsOverwriting($nvHash2) < 0 and defined $infile and ref $infile ne "SCALAR") | 
 
| 2238 | 0 | 0 | unless defined $cTime | 
 
| 2245 | 4 | 232 | if (not defined $outfile and defined $infile) | 
 
| 2249 | 0 | 4 | if defined $hardLink and not length $hardLink | 
 
| 2250 | 0 | 4 | if defined $symLink and not length $symLink | 
 
| 2251 | 0 | 4 | if defined $testName and not length $testName | 
 
| 2254 | 0 | 4 | if (defined $newDir and length $newDir) { } | 
 
| 2255 | 0 | 0 | unless $newDir =~ m[/$] | 
 
| 2259 | 1 | 3 | if ($numNew == $numPseudo) { } | 
 
|  | 0 | 6 | elsif (defined $newFileName and length $newFileName) { } | 
 
| 2261 | 1 | 0 | if (defined $newFileName || defined $newDir and not ref $infile) | 
 
| 2263 | 1 | 0 | if ($result > 0) { } | 
 
|  | 0 | 0 | elsif ($result < 0) { } | 
 
| 2270 | 1 | 0 | if (not ref $infile or UNIVERSAL::isa($infile, "GLOB")) | 
 
| 2271 | 0 | 1 | if $setModDate | 
 
| 2272 | 0 | 1 | if $setCreateDate | 
 
| 2273 | 0 | 1 | if $self->SetSystemTags($infile) > 0 | 
 
| 2275 | 0 | 1 | if (defined $hardLink or defined $symLink or defined $testName) | 
 
| 2276 | 0 | 0 | if $hardLink and $self->SetFileName($infile, $hardLink, "HardLink") | 
 
| 2277 | 0 | 0 | if $symLink and $self->SetFileName($infile, $symLink, "SymLink") | 
 
| 2278 | 0 | 0 | if $testName and $self->SetFileName($infile, $testName, "Test") | 
 
| 2284 | 0 | 0 | if (ref $infile) { } | 
 
|  | 0 | 0 | elsif ($self->IsOverwriting($nvHash, $infile)) { } | 
 
| 2293 | 0 | 3 | if (defined $newDir) | 
 
| 2294 | 0 | 0 | unless defined $outfile or ref $infile | 
 
| 2295 | 0 | 0 | if (defined $outfile) | 
 
| 2297 | 0 | 0 | unless ref $infile | 
 
| 2304 | 5 | 230 | if (ref $infile) { } | 
 
|  | 207 | 23 | elsif (defined $infile and $infile ne '') { } | 
 
|  | 0 | 23 | elsif (not defined $outfile) { } | 
 
| 2306 | 1 | 4 | if (UNIVERSAL::isa($inRef, 'GLOB')) { } | 
 
|  | 0 | 4 | elsif (UNIVERSAL::isa($inRef, 'File::RandomAccess')) { } | 
 
|  | 0 | 4 | elsif ($] >= 5.006 and eval {
	do {
	require Encode;
&Encode::is_utf8($$inRef)
}
} || $@) { } | 
 
| 2313 | 0 | 0 | $] < 5.01 ? : | 
 
|  | 0 | 0 | $@ ? : | 
 
| 2314 | 0 | 0 | if (defined $outfile) { } | 
 
| 2322 | 2 | 205 | unless defined $outfile | 
 
| 2323 | 207 | 0 | if ($self->Open(\*EXIFTOOL_FILE2, $infile)) { } | 
 
| 2340 | 22 | 1 | unless $outType or ref $outfile | 
 
| 2341 | 23 | 0 | if (&CanCreate($outType)) { } | 
 
|  | 0 | 0 | elsif ($outType) { } | 
 
| 2342 | 23 | 0 | if ($self->{'OPTIONS'}{'WriteMode'} =~ /g/i) { } | 
 
| 2359 | 29 | 206 | unless (@fileTypeList) | 
 
| 2360 | 23 | 6 | if ($fileType) { } | 
 
| 2370 | 13 | 222 | if (ref $outfile) { } | 
 
|  | 1 | 221 | elsif (not defined $outfile) { } | 
 
|  | 0 | 221 | elsif ($self->Exists($outfile)) { } | 
 
|  | 221 | 0 | elsif ($self->Open(\*EXIFTOOL_OUTFILE, $outfile, '>')) { } | 
 
| 2372 | 0 | 13 | if (UNIVERSAL::isa($outRef, 'GLOB')) { } | 
 
| 2377 | 13 | 0 | unless defined $$outRef | 
 
| 2383 | 0 | 1 | if ($raf) | 
 
| 2398 | 0 | 0 | $tmpfile ? : | 
 
| 2406 | 235 | 0 | unless $raf | 
 
| 2408 | 1 | 234 | if ($numNew == $numPseudo) { } | 
 
|  | 0 | 234 | elsif (not ref $infile and $infile eq '-' || $infile =~ /\|$/) { } | 
 
| 2413 | 0 | 1 | unless &Write($outRef, $buff) | 
 
| 2429 | 23 | 211 | unless $raf->Read($hdr, 1024) | 
 
| 2430 | 0 | 234 | unless $raf->Seek($inPos, 0) | 
 
| 2435 | 35 | 234 | if ($Image::ExifTool::magicNumber{$type} and length $hdr and not $hdr =~ /^$Image::ExifTool::magicNumber{$type}/s) | 
 
| 2436 | 35 | 0 | if @fileTypeList | 
 
| 2444 | 107 | 127 | if ($type eq 'JPEG' or $type eq 'EXV') { } | 
 
|  | 13 | 114 | elsif ($type eq 'TIFF') { } | 
 
|  | 112 | 2 | elsif (exists $writableType{$type}) { } | 
 
|  | 0 | 2 | elsif ($type eq 'ORF' or $type eq 'RAW') { } | 
 
|  | 2 | 0 | elsif ($type eq 'EXIF') { } | 
 
| 2448 | 0 | 13 | if (grep /^$tiffType$/, @{$Image::ExifTool::noWriteFile{'TIFF'};}) { } | 
 
| 2452 | 0 | 13 | if ($tiffType eq "FFF") | 
 
| 2461 | 85 | 27 | if (ref $writableType{$type} eq 'ARRAY') { } | 
 
| 2478 | 2 | 0 | if (defined $buff) { } | 
 
| 2479 | 2 | 0 | &Write($outRef, $buff) ? : | 
 
| 2487 | 234 | 0 | if $rtnVal | 
 
| 2488 | 0 | 0 | unless @fileTypeList | 
 
| 2490 | 0 | 0 | unless $raf->Seek($inPos, 0) | 
 
| 2491 | 0 | 0 | if (UNIVERSAL::isa($outRef, 'GLOB')) { } | 
 
| 2498 | 0 | 234 | unless ($rtnVal) | 
 
| 2500 | 0 | 0 | if ($seekErr) { } | 
 
|  | 0 | 0 | elsif ($fileType and defined $rtnVal) { } | 
 
|  | 0 | 0 | elsif ($fileType) { } | 
 
| 2503 | 0 | 0 | if ($self->{'VALUE'}{'Error'}) { } | 
 
|  | 0 | 0 | elsif ($fileType eq 'RAW') { } | 
 
| 2508 | 0 | 0 | if ($wrongType) { } | 
 
| 2513 | 0 | 0 | unless $Image::ExifTool::magicNumber{$type} | 
 
| 2514 | 0 | 0 | unless $hdr =~ /^$Image::ExifTool::magicNumber{$type}/s | 
 
| 2524 | 0 | 0 | if $infile and &GetFileType($infile) | 
 
| 2529 | 0 | 0 | if $err | 
 
| 2536 | 235 | 0 | if ($rtnVal > 0) | 
 
| 2537 | 0 | 23 | if ($outType and $type and $outType ne $type) | 
 
| 2539 | 0 | 0 | unless (grep /^$type$/, @types) | 
 
| 2544 | 0 | 235 | if ($rtnVal > 0 and not &Tell($outRef) and not $self->{'VALUE'}{'Error'}) | 
 
| 2546 | 0 | 0 | if (defined $hdr and length $hdr) { } | 
 
| 2547 | 0 | 0 | unless defined $type | 
 
| 2553 | 0 | 235 | if $self->{'VALUE'}{'Error'} | 
 
| 2557 | 1 | 234 | if (defined $outBuff) | 
 
| 2558 | 0 | 1 | if ($rtnVal <= 0 or not $self->{'CHANGED'}) { } | 
 
|  | 1 | 0 | elsif (UNIVERSAL::isa($inRef, 'GLOB')) { } | 
 
| 2569 | 0 | 1 | unless seek $inRef, 0, 2 and ($size = tell $inRef) >= 0 and seek $inRef, 0, 0 and print $inRef $outBuff and $len >= $size || eval {
	do {
	truncate $inRef, $len
}
} | 
 
| 2576 | 207 | 28 | if ($closeIn) | 
 
| 2578 | 0 | 207 | unless close $inRef or not defined $outBuff | 
 
| 2579 | 207 | 0 | if ($rtnVal > 0) | 
 
| 2581 | 0 | 207 | if ($^O eq "darwin" and -s "$infile/..namedfork/rsrc") | 
 
| 2582 | 0 | 0 | if ($self->{'DEL_GROUP'}{'RSRC'}) { } | 
 
| 2589 | 0 | 0 | if ($self->Open(\*SRC, "$infile/..namedfork/rsrc")) { } | 
 
| 2590 | 0 | 0 | if ($self->Open(\*DST, "$outfile/..namedfork/rsrc", '>')) { } | 
 
| 2594 | 0 | 0 | unless print DST $buf | 
 
| 2596 | 0 | 0 | unless close DST or $err | 
 
| 2605 | 0 | 0 | if $err and $self->Error("Error $err Mac OS resource fork", 2) | 
 
| 2609 | 0 | 207 | if $eraseIn | 
 
| 2613 | 221 | 14 | if ($closeOut) | 
 
| 2615 | 0 | 221 | unless close $outRef | 
 
| 2617 | 0 | 221 | if ($rtnVal <= 0) { } | 
 
|  | 2 | 219 | elsif ($tmpfile) { } | 
 
| 2622 | 0 | 2 | unless ($self->Rename($tmpfile, $infile)) | 
 
| 2624 | 0 | 0 | if (not $self->Unlink($infile)) { } | 
 
|  | 0 | 0 | elsif (not $self->Rename($tmpfile, $infile)) { } | 
 
| 2634 | 2 | 0 | if $rtnVal > 0 | 
 
| 2638 | 222 | 0 | if ($rtnVal > 0 and $closeOut || defined $outBuff && ($closeIn || UNIVERSAL::isa($infile, 'GLOB'))) | 
 
| 2639 | 221 | 1 | $closeOut ? : | 
 
| 2641 | 0 | 222 | if $self->SetSystemTags($target) > 0 | 
 
| 2642 | 198 | 24 | if ($closeIn) | 
 
| 2643 | 0 | 198 | if $setModDate and $self->SetFileModifyDate($target, $originalTime, undef, 1) > 0 | 
 
| 2645 | 0 | 198 | if $setCreateDate and $self->SetFileModifyDate($target, $createTime, "FileCreateDate", 1) > 0 | 
 
| 2647 | 0 | 198 | if defined $hardLink and $self->SetFileName($target, $hardLink, "HardLink") | 
 
| 2648 | 0 | 198 | if defined $symLink and $self->SetFileName($target, $symLink, "SymLink") | 
 
| 2649 | 0 | 198 | if defined $testName | 
 
| 2653 | 0 | 235 | if ($rtnVal < 0) { } | 
 
|  | 235 | 0 | elsif ($rtnVal > 0) { } | 
 
| 2654 | 0 | 0 | unless $self->{'VALUE'}{'Error'} | 
 
| 2657 | 5 | 230 | unless $self->{'CHANGED'} | 
 
| 2675 | 0 | 0 | if $group | 
 
| 2685 | 0 | 0 | if ($table->{'GROUPS'} and $table->{'GROUPS'}{'0'} eq "XMP") | 
 
| 2694 | 0 | 0 | unless $tag | 
 
| 2696 | 0 | 0 | if $tagInfo->{'SubDirectory'} and not $tagInfo->{'Writable'} | 
 
| 2697 | 0 | 0 | if $tagInfo->{'Hidden'} | 
 
| 2698 | 0 | 0 | if (@groups) | 
 
| 2701 | 0 | 0 | unless grep /^$group$/i, @tg | 
 
| 2720 | 0 | 0 | if $group | 
 
| 2730 | 0 | 0 | if ($table->{'GROUPS'} and $table->{'GROUPS'}{'0'} eq "XMP") | 
 
| 2735 | 0 | 0 | if (@parts > 3) | 
 
| 2747 | 0 | 0 | unless $tag | 
 
| 2750 | 0 | 0 | unless $writable or $table->{'WRITABLE'} and not defined $writable and not $tagInfo->{'SubDirectory'} | 
 
| 2751 | 0 | 0 | if $tagInfo->{'Hidden'} | 
 
| 2752 | 0 | 0 | if (@groups) | 
 
| 2755 | 0 | 0 | unless grep /^$group$/i, @tg | 
 
| 2774 | 0 | 0 | if ref $family | 
 
| 2776 | 0 | 0 | if $family == 3 | 
 
| 2777 | 0 | 0 | if $family == 4 | 
 
| 2778 | 0 | 0 | if $family == 5 | 
 
| 2779 | 0 | 0 | if $family == 6 | 
 
| 2780 | 0 | 0 | if $family == 8 | 
 
| 2788 | 0 | 0 | if $family == 1 | 
 
| 2793 | 0 | 0 | if $grps = $table->{'GROUPS'} and $grp = $grps->{$family} | 
 
| 2796 | 0 | 0 | if ($family == 7) { } | 
 
| 2799 | 0 | 0 | if (not defined $id) { } | 
 
|  | 0 | 0 | elsif ($id =~ /^\d+$/) { } | 
 
| 2802 | 0 | 0 | if $self and $self->{'OPTIONS'}{'HexTagIDs'} | 
 
| 2810 | 0 | 0 | unless $grps = $tagInfo->{'Groups'} and $grp = $grps->{$family} | 
 
| 2847 | 0 | 2 | unless my $table = &GetTagTable($tableName) | 
 
| 2853 | 0 | 2 | if $Image::ExifTool::specialTags{$tagID} | 
 
| 2880 | 0 | 5400 | if ref $$valPt eq "SCALAR" | 
 
| 2883 | 0 | 5400 | if ($] >= "5.006" and eval {
	do {
	require Encode;
&Encode::is_utf8($$valPt)
}
} || $@) | 
 
| 2886 | 0 | 0 | $] < 5.01 ? : | 
 
|  | 0 | 0 | $@ ? : | 
 
| 2889 | 92 | 5308 | if ($self->{'OPTIONS'}{'Escape'}) | 
 
| 2891 | 0 | 92 | if ($self->{'OPTIONS'}{'Escape'} eq 'XML') { } | 
 
|  | 92 | 0 | elsif ($self->{'OPTIONS'}{'Escape'} eq 'HTML') { } | 
 
| 2913 | 70 | 28206 | unless $convType | 
 
| 2916 | 28276 | 44882 | if (not defined $type) { } | 
 
|  | 21738 | 23144 | elsif ($type eq 'PrintConv') { } | 
 
| 2918 | 583 | 27693 | if ($tagInfo->{'List'}) | 
 
| 2920 | 74 | 0 | if (defined $listSplit and not $tagInfo->{'Struct'} and $wantGroup || !defined($wantGroup)) | 
 
| 2923 | 59 | 0 | if $listSplit eq 1 and $tagInfo->{'AutoSplit'} | 
 
| 2925 | 41 | 0 | @splitVal ? : | 
 
|  | 33 | 41 | @splitVal > 1 ? : | 
 
| 2933 | 13 | 0 | if ($tagInfo->{'RawJoin'} and $tagInfo->{'List'} and not ref $val) | 
 
| 2935 | 13 | 0 | if @splitVal > 1 | 
 
| 2939 | 296 | 22848 | if ($tagInfo->{'WriteCheck'}) | 
 
| 2942 | 0 | 296 | if $@ | 
 
| 2944 | 23110 | 34 | unless ($err2) | 
 
| 2946 | 22225 | 817 | if ($table and $table->{'CHECK_PROC'} and not $tagInfo->{'RawConvInv'}) | 
 
| 2948 | 46 | 22179 | if (ref $val eq 'ARRAY') { } | 
 
| 2952 | 0 | 136 | if $err2 | 
 
| 2959 | 3344 | 19800 | if (defined $err2) | 
 
| 2960 | 3336 | 8 | if ($err2) { } | 
 
| 2973 | 27489 | 22525 | unless defined $conv or defined $convInv | 
 
| 2976 | 12 | 22513 | if (ref $val eq 'ARRAY') { } | 
 
|  | 153 | 22360 | elsif (ref $conv eq 'ARRAY' or ref $convInv eq 'ARRAY') { } | 
 
| 2984 | 153 | 0 | if (ref $conv eq "ARRAY") | 
 
| 2988 | 29 | 124 | if (ref $convInv eq "ARRAY") | 
 
| 2995 | 13657 | 8920 | if ($convInv) { } | 
 
|  | 8917 | 3 | elsif ($conv) { } | 
 
| 2999 | 144 | 13513 | if (ref $convInv eq 'CODE') { } | 
 
| 3004 | 198 | 13315 | if $@ | 
 
| 3006 | 223 | 13434 | if ($Image::ExifTool::evalWarning) { } | 
 
|  | 124 | 13310 | elsif (not defined $val) { } | 
 
| 3008 | 9 | 214 | if ($Image::ExifTool::evalWarning eq "\n") { } | 
 
| 3009 | 9 | 0 | unless defined $err | 
 
| 3022 | 8730 | 187 | if (ref $conv eq 'HASH' and !exists($$tagInfo{"${type}Inv"}) || $convInvList) { } | 
 
|  | 164 | 23 | elsif (not $tagInfo->{'WriteAlso'}) { } | 
 
| 3025 | 0 | 0 | if ($self->{'CUR_LANG'} and $type eq "PrintConv" and ref($lc = $self->{'CUR_LANG'}{$tag}) eq "HASH" and $lc = $lc->{'PrintConv'}) | 
 
| 3032 | 0 | 0 | unless defined $lc->{$val} | 
 
| 3035 | 0 | 0 | if ($conv->{'BITMASK'}) | 
 
| 3038 | 0 | 0 | unless defined $lc->{$val} | 
 
| 3045 | 104 | 8626 | if ($conv->{'BITMASK'}) { } | 
 
| 3049 | 2 | 102 | if ($err2) { } | 
 
|  | 71 | 31 | elsif (defined $val2) { } | 
 
| 3052 | 2 | 0 | unless (defined $val) | 
 
| 3067 | 4619 | 4109 | if (not defined $val) { } | 
 
|  | 0 | 4109 | elsif ($Image::ExifTool::evalWarning) { } | 
 
| 3068 | 2863 | 1756 | $multi ? : | 
 
|  | 0 | 4619 | $Image::ExifTool::evalWarning ? : | 
 
| 3082 | 17321 | 124 | unless @valList | 
 
| 3084 | 72 | 52 | if (++$index >= @valList) | 
 
| 3086 | 12 | 60 | $tagInfo->{'List'} ? : | 
 
| 3089 | 16 | 36 | if $convList | 
 
| 3090 | 11 | 41 | if $convInvList | 
 
| 3125 | 0 | 9 | if ($docGrp) { } | 
 
| 3126 | 0 | 0 | $docGrp =~ /(\d+)$/ ? : | 
 
| 3134 | 0 | 13 | if ($var eq "\$" or $var eq "/") | 
 
| 3135 | 0 | 0 | if $bra | 
 
| 3136 | 0 | 0 | if ($var eq '/') { } | 
 
|  | 0 | 0 | elsif ($line =~ /^self\b/ and not $rtnStr =~ /\$$/) { } | 
 
| 3151 | 0 | 13 | if $line =~ s/^#// | 
 
| 3153 | 1 | 12 | if ($bra and $line =~ s/^\@(#)?//) | 
 
| 3155 | 0 | 1 | if $1 | 
 
| 3159 | 3 | 4 | if ($bra and not $line =~ s/^\s*\}// and $line =~ s/^\s*;\s*(.*?)\s*\}//s) | 
 
| 3166 | 3 | 4 | unless $level and $line =~ s/^(.*?)\s*\}//s | 
 
| 3171 | 0 | 3 | unless length $expr | 
 
| 3175 | 0 | 13 | unless @tags | 
 
| 3182 | 1 | 12 | if $asList | 
 
| 3185 | 0 | 13 | if ($cache and not $lcTag =~ /(^|:)all$/) { } | 
 
| 3188 | 0 | 0 | if $tag =~ s/^(.*):// | 
 
| 3192 | 0 | 0 | unless ($cacheTag) | 
 
| 3197 | 0 | 0 | if defined $group | 
 
| 3199 | 0 | 0 | $ex->{$_} ? : | 
 
| 3200 | 0 | 0 | if (defined $cacheTag->[$doc]) | 
 
| 3201 | 0 | 0 | unless $cacheTag->[$doc] =~ / \((\d+)\)$/ | 
 
| 3204 | 0 | 0 | if / \((\d+)\)$/ and $1 < $cur | 
 
| 3209 | 0 | 0 | $lcTag =~ /\b(main|doc(\d+)):/ ? : | 
 
| 3210 | 0 | 0 | if ($cacheTag->[$doc]) | 
 
| 3216 | 0 | 13 | if ($docGrp and not $lcTag =~ /\b(main|doc\d+):/) | 
 
| 3221 | 3 | 10 | if ($tag =~ s/(\bfile\d+)://i) | 
 
| 3222 | 0 | 3 | unless $et = $self->{'ALT_EXIFTOOL'}{ucfirst lc $1} | 
 
| 3224 | 0 | 13 | if ($lcTag eq 'all') { } | 
 
|  | 0 | 13 | elsif (defined $et->{'OPTIONS'}{'UserParam'}{$lcTag}) { } | 
 
|  | 3 | 10 | elsif ($tag =~ /(.*):(.+)/) { } | 
 
|  | 0 | 10 | elsif ($tag eq 'self') { } | 
 
| 3231 | 0 | 3 | if (lc $tag eq 'all') { } | 
 
| 3234 | 0 | 0 | $match ? : | 
 
| 3240 | 0 | 3 | if (defined $val and $tg =~ / \((\d+)\)$/) | 
 
| 3243 | 0 | 0 | if not $tag =~ / \((\d+)\)$/ or $1 > $tagNum | 
 
| 3247 | 2 | 1 | unless $tag =~ / / | 
 
| 3255 | 7 | 3 | unless (defined $val) | 
 
| 3258 | 7 | 0 | if (defined $tg) | 
 
| 3265 | 1 | 12 | if $asList | 
 
| 3266 | 1 | 12 | if (ref $val eq 'ARRAY') { } | 
 
|  | 0 | 12 | elsif (ref $val eq 'SCALAR') { } | 
 
|  | 0 | 12 | elsif (ref $val eq 'HASH') { } | 
 
|  | 0 | 12 | elsif (not defined $val) { } | 
 
| 3269 | 1 | 0 | unless @tags | 
 
| 3271 | 0 | 0 | if ($self->{'OPTIONS'}{'Binary'} or $$val =~ /^Binary data/) { } | 
 
| 3280 | 0 | 0 | if $asList | 
 
| 3282 | 12 | 0 | unless @tags | 
 
| 3283 | 0 | 0 | if defined $val | 
 
| 3286 | 1 | 12 | if (@val) { } | 
 
| 3287 | 0 | 1 | if defined $val | 
 
| 3290 | 12 | 0 | if defined $val | 
 
| 3293 | 3 | 10 | if (defined $expr and defined $val) | 
 
| 3297 | 1 | 2 | if ($asList) { } | 
 
| 3301 | 0 | 3 | if $@ | 
 
| 3305 | 1 | 0 | @val ? : | 
 
| 3310 | 0 | 2 | if $@ | 
 
| 3311 | 0 | 2 | ref $_ eq 'ARRAY' ? : | 
 
| 3313 | 0 | 3 | if ($Image::ExifTool::evalWarning) | 
 
| 3314 | 0 | 0 | $docGrp && !($var =~ /\b(main|doc\d+):/i) ? : | 
 
| 3316 | 0 | 0 | if ($opt) | 
 
| 3317 | 0 | 0 | if ($opt eq 'Error') { } | 
 
|  | 0 | 0 | elsif ($opt ne 'Silent') { } | 
 
| 3327 | 0 | 13 | unless (defined $val) | 
 
| 3329 | 0 | 0 | unless (defined $val) | 
 
| 3330 | 0 | 0 | $docGrp && !($var =~ /\b(main|doc\d+):/i) ? : | 
 
| 3331 | 0 | 0 | $didExpr ? : | 
 
| 3333 | 0 | 0 | if (ref $opt) { } | 
 
|  | 0 | 0 | elsif ($opt) { } | 
 
| 3334 | 0 | 0 | unless $self->Warn($msg, 2) | 
 
| 3337 | 0 | 0 | if $opt eq "Silent" or &$opt($self, $msg, 2) | 
 
| 3342 | 0 | 13 | if (ref $opt eq 'HASH') { } | 
 
| 3343 | 0 | 0 | if $type | 
 
| 3344 | 0 | 0 | if (defined $expr) | 
 
| 3367 | 0 | 0 | if ($advFmtSelf and defined($shift = $advFmtSelf->{'OPTIONS'}{'GlobalTimeShift'})) | 
 
| 3372 | 0 | 0 | unless defined $_ | 
 
| 3373 | 0 | 0 | if $shift | 
 
| 3383 | 0 | 0 | $advFmtSelf ? : | 
 
| 3385 | 0 | 0 | $_[0] && $new eq $_ ? : | 
 
| 3397 | 0 | 0 | unless (@tagInfo) | 
 
| 3398 | 0 | 0 | if &TagExists($tag) | 
 
| 3403 | 0 | 0 | $tagInfo->{'Writable'} ? : | 
 
|  | 0 | 0 | if defined $tagInfo->{'Writable'} | 
 
| 3404 | 0 | 0 | if $tagInfo->{'Table'}{'WRITABLE'} | 
 
| 3407 | 0 | 0 | if ($writeProc) | 
 
| 3410 | 0 | 0 | if $tagInfo->{'Writable'} | 
 
| 3423 | 0 | 0 | unless lc $file eq lc $file2 | 
 
| 3430 | 0 | 0 | if ($self->Open(\*TMP1, $tmp1, ">")) | 
 
| 3432 | 0 | 0 | if $self->Exists($tmp2) | 
 
| 3436 | 0 | 0 | if ($interrupted and $SIG{'INT'}) | 
 
| 3467 | 0 | 1 | if ($dir and not $self->IsDirectory($dir)) | 
 
| 3472 | 0 | 0 | if (length $dir and not $self->IsDirectory($dir)) | 
 
| 3475 | 0 | 0 | if ($self->EncodeFileName($d2)) { } | 
 
| 3477 | 0 | 0 | unless (eval {
	do {
	require Win32::API
}
}) | 
 
| 3481 | 0 | 0 | unless ($k32CreateDir) | 
 
| 3482 | 0 | 0 | if defined $k32CreateDir | 
 
| 3484 | 0 | 0 | unless ($k32CreateDir) | 
 
| 3490 | 0 | 0 | unless $k32CreateDir->Call($d2, 0) | 
 
| 3492 | 0 | 0 | unless mkdir $d2, 511 | 
 
| 3511 | 2 | 0 | if (defined $mode and not defined $self->GetNewValue("FilePermissions")) | 
 
| 3516 | 2 | 0 | if (defined $uid and defined $gid and not defined $newUid && defined $newGid) | 
 
| 3517 | 0 | 2 | if defined $newGid | 
 
| 3518 | 0 | 2 | if defined $newUid | 
 
| 3532 | 0 | 1 | unless defined $dir | 
 
| 3533 | 0 | 1 | if ($newName =~ m[/$]) { } | 
 
|  | 1 | 0 | elsif (not $newName =~ m[/]) { } | 
 
| 3548 | 0 | 0 | unless exists $info->{$tag} | 
 
| 3552 | 0 | 0 | unless exists $info->{$key} | 
 
| 3563 | 61 | 8665 | unless defined $val | 
 
| 3565 | 40 | 8625 | if ($val =~ /^Unknown\s*\((.*)\)$/i) { } | 
 
| 3567 | 0 | 40 | if ($val =~ /^0x([\da-fA-F]+)$/) | 
 
| 3586 | 15561 | 6524 | unless $matches | 
 
| 3588 | 3212 | 3312 | if ($matches > 1 and not $pattern =~ /\$$/) | 
 
| 3591 | 449 | 9187 | if defined $conv->{$_} and $conv->{$_} =~ /$pattern/ | 
 
| 3593 | 3082 | 130 | if $matches > 1 | 
 
| 3596 | 7325 | 3416 | if not $conv->{$_} =~ /$pattern/ or $ignorePrintConv{$_} | 
 
| 3602 | 5209 | 3416 | unless ($found) | 
 
| 3604 | 792 | 4417 | if ($conv->{'OTHER'}) { } | 
 
| 3611 | 3082 | 2127 | if $matches > 1 | 
 
| 3614 | 8618 | 47 | if wantarray | 
 
| 3630 | 41 | 6190 | unless $nvHash | 
 
| 3632 | 6073 | 117 | unless $nvHash->{'DelValue'} | 
 
| 3635 | 13 | 104 | unless @{$nvHash->{'DelValue'};} or defined $shift | 
 
| 3637 | 58 | 46 | unless defined $val | 
 
| 3641 | 3 | 43 | if ($conv) | 
 
| 3644 | 0 | 3 | if (ref $conv eq 'CODE') { } | 
 
| 3651 | 0 | 3 | if $@ | 
 
| 3653 | 0 | 3 | unless defined $val | 
 
| 3656 | 6 | 40 | if $nvHash->{'CreateOnly'} | 
 
| 3658 | 13 | 27 | if (defined $shift) | 
 
| 3660 | 6 | 7 | unless ($shiftType and $shiftType eq "Time") | 
 
| 3661 | 0 | 6 | unless (&IsFloat($val)) | 
 
| 3664 | 0 | 0 | if (defined $conv) | 
 
| 3667 | 0 | 0 | if (ref $conv eq 'CODE') { } | 
 
|  | 0 | 0 | elsif (not ref $conv) { } | 
 
| 3672 | 0 | 0 | if $@ | 
 
| 3674 | 0 | 0 | if ($Image::ExifTool::evalWarning) | 
 
| 3679 | 0 | 0 | unless (defined $val and &IsFloat($val)) | 
 
| 3688 | 0 | 13 | if ($err) | 
 
| 3694 | 0 | 13 | unless defined $checkVal | 
 
| 3696 | 0 | 13 | if $val eq $nvHash->{'Value'}[0] | 
 
| 3702 | 10 | 22 | if $val eq $delVal | 
 
| 3723 | 5394 | 27117 | unless $writeGroup =~ /^(MakerNotes|XMP|Composite|QuickTime)$/ | 
 
| 3738 | 1 | 67738 | unless $tagInfo | 
 
| 3742 | 41946 | 25792 | if $opts | 
 
| 3743 | 21199 | 46539 | unless defined $writeGroup | 
 
| 3745 | 46539 | 21199 | if ($writeGroup) | 
 
| 3749 | 36 | 1974 | if $nvHash->{'WriteGroup'} =~ /^(QuickTime|All)$/ | 
 
| 3751 | 12 | 1962 | if $tagInfo->{'WriteGroup'} and $tagInfo->{'WriteGroup'} eq "All" | 
 
| 3757 | 2406 | 589 | if (defined $nvHash and $opts{'delete'} || $opts{'create'} && $nvHash->{'Save'}) | 
 
| 3762 | 0 | 2406 | if ($protect and not $opts{'create'} && ($nvHash->{'NoReplace'} || $_[5] || $nvHash->{'DelValue'} && !defined($nvHash->{'Shift'}))) { } | 
 
|  | 2396 | 10 | elsif ($opts{'delete'}) { } | 
 
| 3775 | 65 | 10 | unless ref $copy{$key} eq "ARRAY" | 
 
| 3783 | 0 | 0 | if $protect and $nvHash->{'Value'} | 
 
| 3786 | 23209 | 23488 | if (not defined $nvHash and $opts{'create'}) | 
 
| 3794 | 33 | 23176 | if ($self->{'NEW_VALUE'}{$tagInfo}) { } | 
 
| 3809 | 0 | 0 | if $loadedAllTables | 
 
| 3815 | 0 | 0 | unless $table =~ /:/ | 
 
| 3828 | 0 | 0 | if ($writeProc) | 
 
| 3837 | 0 | 0 | unless my $subdir = $tagInfo->{'SubDirectory'} | 
 
| 3838 | 0 | 0 | unless my $tableName = $subdir->{'TagTable'} | 
 
| 3840 | 0 | 0 | if $Image::ExifTool::allTables{$tableName} or $pushedTables{$tableName} | 
 
| 3856 | 2666 | 0 | if ($nvHash eq $firstHash) { } | 
 
| 3858 | 0 | 2666 | if ($nvHash->{'Next'}) { } | 
 
| 3870 | 80 | 2586 | if ($nvHash->{'Save'}) | 
 
| 3885 | 777 | 7 | unless $self->{'NEW_VALUE'} | 
 
| 3889 | 2 | 5 | if $removeGroups{$group} | 
 
| 3892 | 0 | 7 | if $self->{'OPTIONS'}{'Verbose'} > 1 | 
 
| 3905 | 1581 | 410 | if $wgrp eq $grp0 | 
 
| 3906 | 270 | 1721 | if (grep /^($grp0|$wgrp)$/i, @groups) | 
 
| 3907 | 0 | 270 | if $out | 
 
| 3911 | 1985 | 6 | unless $nvHash = $nextHash | 
 
| 3925 | 1183 | 24 | if ($nv) | 
 
| 3929 | 56945 | 32539 | if $tagTablePtr and $tagTablePtr ne $tagInfo->{'Table'} | 
 
| 3950 | 21270 | 288 | if $tagTablePtr and $tagTablePtr ne $tagInfo->{'Table'} | 
 
| 3966 | 30 | 430 | unless $parent | 
 
| 3976 | 152777 | 34442 | unless $tagInfo->{'SubDirectory'} | 
 
| 3981 | 3797 | 30645 | unless ($dirName) | 
 
| 3987 | 254 | 34188 | if ($editDirs->{$dirName} and $editDirs->{$dirName} eq $parent) | 
 
| 3989 | 141 | 113 | if $addDirs->{$dirName} | 
 
| 3993 | 76 | 384 | if wantarray | 
 
| 4009 | 182 | 116 | unless ($langInfo) | 
 
| 4039 | 192 | 126 | unless ($fileDirs) | 
 
| 4040 | 112 | 80 | unless ref $fileType eq "HASH" | 
 
| 4054 | 3536 | 9449 | if ($preferredGroup) | 
 
| 4056 | 826 | 2710 | if ($isCreating) { } | 
 
| 4061 | 141 | 1 | if $preferredGroup ne $g0 and $nvHash->{'CreateGroups'}{$preferredGroup} and !$altGroup || $altGroup ne $g0 | 
 
| 4067 | 92 | 0 | if $nvHash->{'Value'} and $preferredGroup eq $g0 and not $nvHash->{'EditOnly'} and $self->{'OPTIONS'}{'WriteMode'} =~ /g/ | 
 
| 4074 | 388 | 12597 | if ($dirName =~ /^MIE\d*(-[a-z]+)?\d*$/i) | 
 
| 4079 | 0 | 12985 | if ($dirName eq '*' and $nvHash->{'Value'}) { } | 
 
|  | 46 | 12939 | elsif ($dirName eq 'QuickTime') { } | 
 
| 4081 | 0 | 0 | if ($val) | 
 
| 4083 | 0 | 0 | unless $val =~ /\b($_|All)\b/i | 
 
| 4085 | 0 | 0 | if $_ eq "FixBase" | 
 
| 4096 | 6366 | 46364 | if (ref $parent) | 
 
| 4101 | 5317 | 47413 | if $isCreating and $isCreating != 2 | 
 
| 4106 | 37 | 169 | if (%{$self->{'DEL_GROUP'};}) | 
 
| 4109 | 2 | 841 | if /^-/ | 
 
| 4112 | 73 | 768 | if $translateWriteGroup{$dirName} | 
 
| 4114 | 26 | 815 | if $dirName =~ /^XMP-/ | 
 
| 4118 | 13 | 1186 | if (ref $parent) | 
 
| 4128 | 86 | 38 | if ($editDirs->{'IFD0'} and $fileDirs->{'JFIF'}) | 
 
| 4133 | 2 | 204 | if ($self->{'OPTIONS'}{'Verbose'}) | 
 
| 4138 | 0 | 2 | unless $self->{'OPTIONS'}{'Verbose'} > 1 | 
 
| 4155 | 0 | 1728 | unless $tagTablePtr | 
 
| 4156 | 4 | 1724 | if $self->{'OPTIONS'}{'Verbose'} | 
 
| 4161 | 584 | 1144 | unless $dirName | 
 
| 4162 | 207 | 1521 | if (%{$self->{'DEL_GROUP'};}) | 
 
| 4166 | 97 | 110 | unless $permanentDir{$grp0} | 
 
| 4168 | 40 | 167 | if ($delFlag) | 
 
| 4169 | 0 | 40 | if ($grp0 =~ /^(MakerNotes)$/ || $grp1 =~ /^(IFD0|ExifIFD|MakerNotes)$/ and $self->IsRawType and !($dirInfo->{'TagInfo'} && defined $dirInfo->{'TagInfo'}{'Permanent'}) || $dirInfo->{'TagInfo'}{'Permanent'}) { } | 
 
|  | 10 | 30 | elsif (not $blockExifTypes{$self->{'FILE_TYPE'}}) { } | 
 
| 4180 | 0 | 10 | if ($self->{'FILE_TYPE'} eq 'PSD') { } | 
 
|  | 0 | 10 | elsif ($self->{'FILE_TYPE'} =~ /^(EPS|PS)$/) { } | 
 
|  | 0 | 10 | elsif ($grp1 eq 'IFD0') { } | 
 
|  | 0 | 10 | elsif ($grp0 eq 'EXIF' and $delGroup->{$grp0}) { } | 
 
| 4182 | 0 | 0 | if $grp0 eq "Photoshop" | 
 
| 4187 | 0 | 0 | if $delGroup->{'IFD0'} | 
 
| 4190 | 0 | 0 | unless $delGroup->{$grp1} or $grp1 eq "ExifIFD" | 
 
| 4193 | 40 | 0 | if ($grp1) | 
 
| 4194 | 30 | 10 | if ($dataPt or $dirInfo->{'RAF'}) | 
 
| 4196 | 1 | 29 | if $out | 
 
| 4197 | 3 | 27 | if $grp1 eq "ICC_Profile" | 
 
| 4199 | 6 | 24 | if $dirName =~ /IFD/ | 
 
| 4205 | 1 | 39 | if not $right and $grp1 eq "EXIF" | 
 
| 4206 | 21 | 19 | if ($delFlag == 2 and $right) { } | 
 
| 4210 | 21 | 0 | if (not $parent or $parent eq $right or $parent eq $right2) { } | 
 
| 4213 | 9 | 12 | unless $self->{'Recreated'} | 
 
| 4214 | 0 | 21 | if ($self->{'Recreated'}{$path}) | 
 
| 4215 | 0 | 0 | $parent ? : | 
 
| 4234 | 18 | 1 | unless $dirInfo->{'NoDelete'} | 
 
| 4240 | 232 | 1478 | unless $writeProc or $writeProc = $tagTablePtr->{'WRITE_PROC'} | 
 
| 4247 | 202 | 1276 | if $blockName eq "IFD0" | 
 
| 4253 | 1 | 12 | if ($blockName eq "EXIF") | 
 
| 4254 | 0 | 1 | unless ($blockExifTypes{$self->{'FILE_TYPE'}}) | 
 
| 4262 | 0 | 1 | unless $writeProc eq \&Image::ExifTool::WriteTIFF | 
 
| 4264 | 5 | 8 | $dataPt ? : | 
 
|  | 0 | 13 | unless $self->IsOverwriting($nvHash, $dataPt ? $$dataPt : "") | 
 
| 4267 | 0 | 13 | unless (defined $newVal and length $newVal) | 
 
| 4268 | 0 | 0 | unless $dataPt or $dirInfo->{'RAF'} | 
 
| 4270 | 0 | 0 | if ($blockName eq "MakerNotes" and $rawType{$self->{'FileType'}}) | 
 
| 4278 | 0 | 13 | if $out | 
 
| 4283 | 691 | 547 | if (defined $dataPt and defined $dirInfo->{'DirStart'} and defined $dirInfo->{'DataPos'} and not $dirInfo->{'NoRefTest'}) | 
 
| 4288 | 0 | 691 | if ($self->{'PROCESSED'}{$addr} and $dirName ne 'ICC_Profile' || $self->{'TIFF_TYPE'} ne 'IIQ') { } | 
 
| 4289 | 0 | 0 | if (defined $dirInfo->{'DirLen'} and not $dirInfo->{'DirLen'} and $dirName ne $self->{'PROCESSED'}{$addr}) { } | 
 
|  | 0 | 0 | elsif ($self->Error("$dirName pointer references previous $self->{'PROCESSED'}{$addr} directory", 2)) { } | 
 
| 4296 | 0 | 0 | if $out | 
 
| 4309 | 4 | 1461 | if ($out) | 
 
| 4311 | 0 | 4 | $dirName eq 'MakerNotes' && $dirInfo->{'TagInfo'} ? : | 
 
| 4312 | 3 | 1 | if (not defined $oldDir or $oldDir ne $name) | 
 
| 4313 | 1 | 2 | $isRewriting ? : | 
 
| 4329 | 56 | 1409 | unless defined $newData and length $newData || $isRewriting | 
 
| 4333 | 4 | 1461 | if ($out) | 
 
| 4334 | 0 | 4 | if defined $newData and not length $newData | 
 
| 4335 | 0 | 4 | if ($self->{'CHANGED'} == $oldChanged and $self->{'OPTIONS'}{'Verbose'} > 2) | 
 
| 4348 | 12 | 0 | &GetByteOrder() eq 'MM' ? : | 
 
| 4356 | 78 | 111 | &GetByteOrder() eq 'MM' ? : | 
 
| 4366 | 0 | 0 | $val > 0 ? : | 
 
| 4373 | 1 | 0 | &GetByteOrder() eq 'MM' ? : | 
 
| 4376 | 0 | 1 | $exp & 32768 ? : | 
 
| 4406 | 0 | 169 | if defined $opts{'Len'} | 
 
| 4408 | 70 | 99 | unless defined $addr | 
 
| 4409 | 4 | 165 | unless defined $len | 
 
| 4410 | 5 | 164 | if ($maxLen and $len > $maxLen) | 
 
| 4416 | 0 | 169 | if ($len > $datLen) | 
 
| 4425 | 159 | 69 | if $wid > $len - $i | 
 
| 4433 | 5 | 164 | if $more | 
 
| 4460 | 578 | 39 | if (defined $tagID) { } | 
 
| 4461 | 563 | 15 | if $tagID =~ /^\d+$/ | 
 
| 4466 | 617 | 0 | if ($tagInfo and $tagInfo->{'Name'}) { } | 
 
| 4470 | 0 | 0 | if $parms{'Table'} | 
 
| 4471 | 0 | 0 | if ($prefix or $hexID) { } | 
 
| 4472 | 0 | 0 | unless $prefix | 
 
| 4473 | 0 | 0 | $hexID ? : | 
 
| 4480 | 0 | 617 | unless defined $size or not $dataPt | 
 
| 4486 | 365 | 252 | if (defined $index) | 
 
| 4488 | 172 | 193 | if length $index < 2 | 
 
| 4492 | 39 | 578 | if ($tagInfo and $tagInfo->{'SubDirectory'}) { } | 
 
| 4497 | 578 | 0 | if (defined $val) { } | 
 
|  | 0 | 0 | elsif ($dataPt) { } | 
 
| 4498 | 0 | 578 | if ref $val eq "ARRAY" | 
 
| 4508 | 0 | 40 | if ($verbose > 1 and $parms{'Extra'} || $parms{'Format'} || $parms{'DataPt'} || defined $size || $tagID =~ m[/]) | 
 
| 4512 | 389 | 1 | if ($hexID) { } | 
 
| 4518 | 0 | 390 | if defined $parms{'Extra'} | 
 
| 4520 | 390 | 0 | if ($format or defined $size) | 
 
| 4522 | 390 | 0 | if (defined $size) | 
 
| 4524 | 352 | 38 | if $format | 
 
| 4526 | 352 | 38 | if ($format) | 
 
| 4528 | 352 | 0 | if $parms{'Count'} | 
 
| 4532 | 165 | 0 | if $verbose > 2 and $parms{'DataPt'} | 
 
| 4537 | 165 | 18 | if ($verbose > 2 and $parms{'DataPt'} and not $tagInfo && $tagInfo->{'ReadFromRAF'}) | 
 
| 4541 | 165 | 0 | $verbose == 3 ? : | 
 
|  | 165 | 0 | if $verbose < 5 | 
 
| 4561 | 0 | 1 | unless defined $pos | 
 
| 4565 | 0 | 1 | unless ($size) | 
 
| 4566 | 0 | 0 | unless $raf->Seek(0, 2) | 
 
| 4568 | 0 | 0 | unless $size | 
 
| 4570 | 0 | 1 | unless $raf->Seek($pos, 0) | 
 
| 4571 | 0 | 1 | if ($htmlDump) | 
 
| 4572 | 0 | 0 | unless my $num = $raf->Read($buff, $size) | 
 
| 4574 | 0 | 0 | if $trailer eq "Unknown" | 
 
| 4580 | 1 | 0 | unless $verbose > 2 | 
 
| 4583 | 0 | 0 | if ($verbose < 5) | 
 
| 4584 | 0 | 0 | $verbose < 4 ? : | 
 
| 4585 | 0 | 0 | if $num > $limit | 
 
| 4587 | 0 | 0 | unless $raf->Read($buff, $num) == $num | 
 
| 4589 | 0 | 0 | if ($size > 2 * $num) { } | 
 
|  | 0 | 0 | elsif ($size > $num) { } | 
 
| 4599 | 0 | 0 | if (defined $buf2) | 
 
| 4625 | 0 | 0 | if $prePos and $preLen and $prePos + $preLen > $pos | 
 
| 4626 | 0 | 0 | if $lastOne | 
 
| 4630 | 0 | 0 | if (defined $prePos) { } | 
 
| 4642 | 0 | 0 | if ($pos < $prePos) | 
 
| 4650 | 0 | 0 | unless $preLen | 
 
| 4652 | 0 | 0 | if ($self->{'OPTIONS'}{'Verbose'}) | 
 
| 4681 | 1045 | 14 | unless $_[0]{'OPTIONS'}{'Verbose'} > 1 | 
 
| 4684 | 9 | 5 | unless $xtra | 
 
| 4699 | 0 | 0 | if $ch < 128 | 
 
| 4702 | 0 | 0 | if $ch < 32 | 
 
| 4705 | 0 | 0 | if $ch < 16 | 
 
| 4723 | 0 | 0 | if ($_[0] =~ /([\x80-\xff])/g) { } | 
 
| 4731 | 0 | 0 | if $len | 
 
| 4732 | 0 | 0 | unless defined $ch | 
 
| 4737 | 0 | 0 | if ($ch < 194 or $ch >= 248) | 
 
| 4744 | 0 | 0 | if ($ch < 224) { } | 
 
|  | 0 | 0 | elsif ($ch < 240) { } | 
 
| 4753 | 0 | 0 | unless ($_[0] =~ /\G([\x80-\xbf]{$n})/g) | 
 
| 4776 | 15 | 46 | unless defined $guidCount and ++$guidCount < 256 | 
 
| 4791 | 0 | 0 | unless $res | 
 
| 4794 | 0 | 0 | if (not $cmap) { } | 
 
|  | 0 | 0 | elsif (length $cmap == 3 * 2 ** $bits) { } | 
 
|  | 0 | 0 | elsif (length $cmap != 6 * 2 ** $bits) { } | 
 
| 4802 | 0 | 0 | $cmap ? : | 
 
| 4803 | 0 | 0 | $cols == 1 ? : | 
 
|  | 0 | 0 | $cols == 1 ? : | 
 
|  | 0 | 0 | $cmap ? : | 
 
|  | 0 | 0 | $cmap ? : | 
 
| 4844 | 0 | 61 | unless ref $self | 
 
| 4845 | 0 | 61 | if ($self->{'Now'}) { } | 
 
| 4856 | 61 | 0 | if $tzFlag or not defined $tzFlag | 
 
| 4876 | 6 | 431 | if (not $fmt and $val =~ s/([-+])(\d{1,2}):?(\d{2})\s*(DST)?$//i) { } | 
 
|  | 0 | 431 | elsif (not $fmt and $val =~ s/Z$//i) { } | 
 
| 4883 | 0 | 431 | if lc $val eq "now" | 
 
| 4886 | 0 | 437 | if ($fmt) | 
 
| 4887 | 0 | 0 | unless (defined $strptimeLib) | 
 
| 4888 | 0 | 0 | if (eval {
	do {
	require POSIX::strptime
}
}) { } | 
 
|  | 0 | 0 | elsif (eval {
	do {
	require Time::Piece
}
}) { } | 
 
| 4900 | 0 | 0 | $fmt =~ s/%f$// && $val =~ s/(\.\d+)\s*$// ? : | 
 
| 4903 | 0 | 0 | if (not $lib) { } | 
 
|  | 0 | 0 | elsif ($lib eq 'POSIX::strptime') { } | 
 
| 4904 | 0 | 0 | unless $self->{'OPTIONS'}{'StrictDate'} | 
 
| 4911 | 0 | 0 | if ($^O eq "MSWin32" and $fmt =~ /%s/ and $val =~ /-\d/) | 
 
| 4920 | 0 | 0 | if (defined $a[5] and length $a[5]) { } | 
 
| 4926 | 0 | 0 | if defined $a[4] and length $a[4] | 
 
| 4929 | 0 | 0 | if (not defined $a[$i] && length $a[$i]) { } | 
 
|  | 0 | 0 | elsif (length $a[$i] < 2) { } | 
 
| 4930 | 0 | 0 | if ($i < 2 or $dateOnly) { } | 
 
| 4944 | 430 | 7 | if ($val =~ /(\d{4})/g) | 
 
| 4948 | 404 | 26 | if (@a >= 3) { } | 
 
|  | 26 | 0 | elsif ($dateOnly) { } | 
 
| 4952 | 5 | 399 | @a > 5 && $val =~ /(\.\d+)\s*$/ ? : | 
 
| 4954 | 34 | 370 | if ($tzFlag) { } | 
 
|  | 92 | 278 | elsif (defined $tzFlag) { } | 
 
| 4955 | 34 | 0 | unless ($tz) | 
 
| 4956 | 34 | 0 | if (eval {
	do {
	require Time::Local
}
}) { } | 
 
| 4968 | 403 | 1 | if (defined $ss and $ss < 60) { } | 
 
|  | 1 | 0 | elsif ($dateOnly) { } | 
 
| 4976 | 0 | 404 | if ($a[0] < 1 or $a[0] > 12) | 
 
| 4980 | 0 | 404 | if ($a[1] < 1 or $a[1] > 31) | 
 
| 4984 | 0 | 404 | if $a[2] > 24 | 
 
| 4985 | 0 | 404 | if $a[3] > 59 | 
 
| 4991 | 7 | 430 | unless $rtnVal | 
 
| 5011 | 0 | 44 | unless (&SetByteOrder($byteOrder)) | 
 
| 5012 | 0 | 0 | if $self->Options("Verbose") | 
 
| 5026 | 1551 | 3417 | if @_ < 3 | 
 
| 5045 | 0 | 741 | if $val eq "inf" | 
 
| 5046 | 0 | 741 | if $val eq "undef" | 
 
| 5047 | 16 | 725 | if $val =~ m[^([-+]?\d+)/(\d+)$] | 
 
| 5049 | 39 | 686 | if $val == 0 | 
 
| 5050 | 12 | 674 | $val < 0 ? : | 
 
| 5056 | 0 | 1551 | if ($n > $maxInt or $d > $maxInt) | 
 
| 5057 | 0 | 0 | if defined $num | 
 
| 5058 | 0 | 0 | if $val < 1 | 
 
| 5063 | 686 | 865 | if abs $err < "1e-08" | 
 
| 5066 | 0 | 865 | unless $frac -= $int | 
 
| 5079 | 10 | 178 | if $val < 0 | 
 
| 5085 | 12 | 57 | if $val < 0 | 
 
| 5094 | 27 | 1 | &GetByteOrder() eq 'MM' ? : | 
 
| 5095 | 27 | 1 | if $_[1] | 
 
| 5101 | 0 | 0 | if $val < 0 | 
 
| 5107 | 0 | 428 | if $_[1] | 
 
| 5113 | 0 | 44 | if $_[1] | 
 
| 5119 | 0 | 0 | if $_[1] | 
 
| 5125 | 0 | 0 | if $_[1] | 
 
| 5134 | 0 | 0 | $val < 0 ? : | 
 
| 5142 | 2 | 10 | $val < 0 ? : | 
 
| 5146 | 0 | 62 | if $_[1] | 
 
| 5152 | 0 | 64 | if $_[1] | 
 
| 5212 | 1238 | 360 | if ($proc) { } | 
 
|  | 360 | 0 | elsif ($format eq 'string' or $format eq 'undef') { } | 
 
| 5214 | 662 | 576 | if ($count) { } | 
 
| 5215 | 64 | 598 | if $count < 0 | 
 
| 5222 | 0 | 1721 | unless defined $val | 
 
| 5224 | 1232 | 489 | if ($format =~ /^int/) { } | 
 
|  | 7 | 482 | elsif (not &IsFloat($val)) { } | 
 
| 5225 | 0 | 1232 | unless (&IsInt($val) or &IsHex($val)) | 
 
| 5226 | 0 | 0 | unless &IsFloat($val) | 
 
| 5228 | 0 | 0 | $val < 0 ? : | 
 
| 5232 | 0 | 7 | unless $format =~ /^rational/ and $val eq 'inf' || $val eq 'undef' || &IsRational($val) | 
 
| 5238 | 187 | 173 | if $format eq "string" | 
 
| 5239 | 61 | 299 | if ($count and $count > 0) { } | 
 
| 5241 | 29 | 32 | if ($diff) | 
 
| 5244 | 22 | 7 | if ($diff < 0) { } | 
 
| 5245 | 22 | 0 | if ($format eq 'string') { } | 
 
| 5246 | 0 | 22 | unless $count | 
 
| 5258 | 2 | 358 | if $dataPt | 
 
| 5264 | 215 | 1023 | if $dataPt | 
 
| 5276 | 102 | 2 | unless $bits | 
 
| 5277 | 102 | 2 | unless $num | 
 
| 5280 | 85 | 19 | if ($val ne "(none)") | 
 
| 5284 | 42 | 0 | if ($lookup) { } | 
 
| 5287 | 33 | 9 | unless (defined $bit) | 
 
| 5288 | 0 | 33 | if ($val =~ /\[(\d+)\]/) { } | 
 
| 5292 | 31 | 2 | unless @vals > 1 and wantarray | 
 
| 5299 | 0 | 9 | unless (&IsInt($bit) and $bit < $num) | 
 
| 5300 | 0 | 0 | unless wantarray | 
 
| 5301 | 0 | 0 | &IsInt($bit) ? : | 
 
| 5317 | 296 | 29 | if (UNIVERSAL::isa($outfile, 'GLOB')) { } | 
 
| 5331 | 2311 | 1425 | if (UNIVERSAL::isa($outfile, 'GLOB')) { } | 
 
|  | 1425 | 0 | elsif (ref $outfile eq 'SCALAR') { } | 
 
| 5347 | 0 | 12 | if ($self->{'DEL_GROUP'}{'Trailer'}) | 
 
| 5355 | 8 | 4 | if ($trailInfo->{'Fixup'}) | 
 
| 5356 | 8 | 0 | if ($pos > 0) { } | 
 
| 5377 | 2 | 128 | if ref $types[0] | 
 
| 5378 | 128 | 2 | unless $types[0] | 
 
| 5380 | 123 | 7 | unless @types | 
 
| 5384 | 243 | 10 | unless $self->{'NEW_VALUE'}{$Image::ExifTool::Extra{$type}} | 
 
| 5385 | 1 | 9 | if $$self{"Did$type"} | 
 
| 5386 | 1 | 8 | unless my $val = $self->GetNewValue($type) | 
 
| 5388 | 3 | 5 | if ($type eq "CanonDR4") | 
 
| 5389 | 1 | 2 | if $self->{'DidCanonVRD'} | 
 
| 5394 | 0 | 7 | $trailPt ? : | 
 
| 5396 | 0 | 7 | if ($trailPt) { } | 
 
| 5416 | 32 | 78 | unless $type | 
 
| 5421 | 3 | 107 | if $type eq "ICC" | 
 
| 5429 | 0 | 110 | if ($size > $maxLen) | 
 
| 5433 | 0 | 0 | if $type eq "EXIF" and $n + $maxLen <= $len - 4 and substr($$dataPt, $n + $maxLen, 4) =~ /^(MM\0\x2a|II\x2a\0)/ | 
 
| 5439 | 3 | 107 | if ($type eq "ICC") | 
 
| 5445 | 0 | 110 | unless &Write($outfile, $segHdr, $header, $buff) | 
 
| 5446 | 110 | 0 | if $n >= $len | 
 
| 5463 | 0 | 34 | if ($size > $maxXMPLen) | 
 
| 5468 | 0 | 34 | unless &Write($outfile, $app1hdr, $Image::ExifTool::xmpAPP1hdr, $$dataPt) | 
 
| 5470 | 0 | 34 | if (defined $guid) | 
 
| 5477 | 0 | 0 | if $len > $maxLen | 
 
| 5480 | 0 | 0 | unless &Write($outfile, $app1hdr, $Image::ExifTool::xmpExtAPP1hdr, $guid, pack("N2", $size, $off), substr($$extPt, $off, $len)) | 
 
| 5504 | 2 | 109 | unless ($raf->Read($s, 2) == 2 and $s eq "\377\330") | 
 
| 5505 | 1 | 1 | if (defined $s and length $s) { } | 
 
| 5506 | 0 | 1 | unless $s eq "\377\1" and $raf->Read($s, 5) == 5 and $s eq "Exiv2" | 
 
| 5508 | 0 | 1 | unless $self->{'FILE_TYPE'} eq "EXV" | 
 
| 5512 | 0 | 2 | unless &Write($outfile, "\377\1") | 
 
| 5519 | 0 | 111 | unless &Write($outfile, $s) | 
 
| 5536 | 1 | 795 | unless $raf->ReadLine($s) | 
 
| 5539 | 0 | 795 | unless $raf->Read($ch, 1) | 
 
| 5541 | 795 | 0 | unless $marker == 255 | 
 
| 5545 | 110 | 685 | if ($marker == 218 or $marker == 217) | 
 
| 5552 | 109 | 576 | if (($marker & 240) == 192 and $marker == 192 || $marker & 3) { } | 
 
|  | 576 | 0 | elsif ($marker != 0 and $marker != 1 and $marker < 208 || $marker > 215) { } | 
 
| 5553 | 0 | 109 | unless $raf->Seek(7, 1) | 
 
| 5558 | 0 | 576 | unless $raf->Read($s, 2) == 2 | 
 
| 5560 | 0 | 576 | unless defined $len and $len >= 2 | 
 
| 5562 | 347 | 229 | if (($marker & 240) == 224) | 
 
| 5563 | 86 | 261 | $len < 64 ? : | 
 
| 5564 | 0 | 347 | unless $raf->Read($s, $n) == $n | 
 
| 5568 | 45 | 302 | if ($marker == 224) { } | 
 
|  | 84 | 218 | elsif ($marker == 225) { } | 
 
|  | 55 | 163 | elsif ($marker == 226) { } | 
 
|  | 9 | 154 | elsif ($marker == 227) { } | 
 
|  | 9 | 145 | elsif ($marker == 229) { } | 
 
|  | 19 | 126 | elsif ($marker == 236) { } | 
 
|  | 29 | 97 | elsif ($marker == 237) { } | 
 
|  | 16 | 81 | elsif ($marker == 238) { } | 
 
| 5569 | 18 | 27 | if $s =~ /^JFIF\0/ | 
 
| 5570 | 9 | 36 | if $s =~ /^JFXX\0\x10/ | 
 
| 5571 | 9 | 36 | if $s =~ /^(II|MM).{4}HEAPJPGM/s | 
 
| 5573 | 60 | 24 | if ($s =~ /^(.{0,4})Exif\0.(.{1,4})/is) | 
 
| 5577 | 0 | 0 | if (@dirOrder and $dirOrder[-1] =~ /^(IFD0|ExtendedEXIF)$/ and not length $junk and not $bytes =~ /^(MM\0\x2a|II\x2a\0)/) | 
 
| 5583 | 22 | 62 | if $s =~ /^$Image::ExifTool::xmpAPP1hdr/ | 
 
| 5584 | 2 | 82 | if $s =~ /^$Image::ExifTool::xmpExtAPP1hdr/ | 
 
| 5586 | 14 | 41 | if $s =~ /^ICC_PROFILE\0/ | 
 
| 5587 | 32 | 23 | if $s =~ /^FPXR\0/ | 
 
| 5588 | 9 | 46 | if $s =~ /^MPF\0/ | 
 
| 5590 | 9 | 0 | if $s =~ /^(Meta|META|Exif)\0\0/ | 
 
| 5592 | 9 | 0 | if $s =~ /^RMETA\0/ | 
 
| 5594 | 10 | 9 | if $s =~ /^Ducky/ | 
 
| 5596 | 20 | 9 | if $s =~ /^$Image::ExifTool::psAPP13hdr/ | 
 
| 5598 | 16 | 0 | if $s =~ /^Adobe/ | 
 
| 5602 | 209 | 138 | if defined $dirName and not $delGroup->{$dirName} | 
 
| 5604 | 0 | 576 | unless $raf->Seek($len, 1) | 
 
| 5606 | 446 | 239 | unless $dirName | 
 
| 5610 | 2 | 109 | unless ($marker and $marker == 218) | 
 
| 5611 | 0 | 2 | unless $isEXV | 
 
| 5612 | 0 | 2 | if $marker and $marker != 217 | 
 
| 5614 | 0 | 111 | unless $raf->Seek($pos, 0) | 
 
| 5625 | 1 | 795 | unless $raf->ReadLine($segJunk) | 
 
| 5629 | 109 | 687 | if length $segJunk | 
 
| 5632 | 795 | 1 | if ($raf->Read($ch, 1)) { } | 
 
|  | 1 | 0 | elsif ($creatingEXV) { } | 
 
| 5634 | 795 | 0 | unless $marker == 255 | 
 
| 5649 | 109 | 687 | if (($marker & 240) == 192 and $marker == 192 || $marker & 3) { } | 
 
|  | 685 | 2 | elsif ($marker != 0 and $marker != 1 and $marker != 217 and $marker < 208 || $marker > 215) { } | 
 
| 5650 | 0 | 109 | unless $raf->Read($segData, 7) == 7 | 
 
| 5657 | 0 | 685 | unless $raf->Read($s, 2) == 2 | 
 
| 5659 | 0 | 685 | unless defined $len and $len >= 2 | 
 
| 5662 | 0 | 685 | unless $raf->Read($segData, $len) == $len | 
 
| 5673 | 1 | 795 | if (exists $addDirs->{'JFIF'} and not defined $doneDir{'JFIF'}) | 
 
| 5675 | 1 | 0 | if (defined $doneDir{'Adobe'}) { } | 
 
| 5680 | 0 | 0 | if ($verbose) | 
 
| 5699 | 0 | 0 | if defined $delJFIF | 
 
| 5700 | 0 | 0 | if (defined $newData and length $newData) | 
 
| 5702 | 0 | 0 | unless &Write($outfile, $app0hdr, "JFIF\0", $newData) | 
 
| 5707 | 60 | 691 | if $markerName eq "APP0" or $dirCount{'IFD0'} or $dirCount{'ExtendedEXIF'} | 
 
| 5709 | 31 | 660 | if (exists $addDirs->{'IFD0'} and not defined $doneDir{'IFD0'}) | 
 
| 5711 | 1 | 30 | if $verbose | 
 
| 5721 | 29 | 2 | if (defined $buff and length $buff) | 
 
| 5722 | 0 | 29 | if (length($buff) + length($Image::ExifTool::exifAPP1hdr) > $maxSegmentLen) | 
 
| 5723 | 0 | 0 | if ($self->Options('NoMultiExif')) { } | 
 
| 5730 | 0 | 29 | if ($self->{'PREVIEW_INFO'} || $self->{'LeicaTrailer'} and not $oldOutfile) | 
 
| 5735 | 0 | 0 | if $self->{'PREVIEW_INFO'} | 
 
| 5736 | 0 | 0 | if $self->{'LeicaTrailer'} | 
 
| 5740 | 0 | 29 | if (not $n) { } | 
 
|  | 0 | 58 | elsif ($n > 1 and $oldOutfile) { } | 
 
| 5750 | 182 | 509 | if $dirCount{'Photoshop'} | 
 
| 5751 | 19 | 490 | if (exists $addDirs->{'Photoshop'} and not defined $doneDir{'Photoshop'}) | 
 
| 5753 | 0 | 19 | if $verbose | 
 
| 5761 | 19 | 0 | if (defined $buff and length $buff) | 
 
| 5762 | 0 | 19 | unless &WriteMultiSegment($outfile, 237, $Image::ExifTool::psAPP13hdr, \$buff) | 
 
| 5767 | 15 | 494 | if $dirCount{'XMP'} | 
 
| 5768 | 27 | 467 | if (exists $addDirs->{'XMP'} and not defined $doneDir{'XMP'}) | 
 
| 5770 | 0 | 27 | if $verbose | 
 
| 5780 | 27 | 0 | if (defined $buff and length $buff) | 
 
| 5782 | 0 | 27 | unless &WriteMultiXMP($self, $outfile, \$buff, $dirInfo{'ExtendedXMP'}, $dirInfo{'ExtendedGUID'}) | 
 
| 5786 | 5 | 489 | if $dirCount{'ICC_Profile'} | 
 
| 5787 | 3 | 486 | if (exists $addDirs->{'ICC_Profile'} and not defined $doneDir{'ICC_Profile'}) | 
 
| 5789 | 0 | 3 | if $delGroup->{'ICC_Profile'} and $delGroup->{'ICC_Profile'} != 2 | 
 
| 5790 | 0 | 3 | if $verbose | 
 
| 5798 | 3 | 0 | if (defined $buff and length $buff) | 
 
| 5799 | 0 | 3 | unless &WriteMultiSegment($outfile, 226, "ICC_PROFILE\0", \$buff, "ICC") | 
 
| 5804 | 1 | 488 | if $dirCount{'Ducky'} | 
 
| 5805 | 2 | 486 | if (exists $addDirs->{'Ducky'} and not defined $doneDir{'Ducky'}) | 
 
| 5807 | 0 | 2 | if $verbose | 
 
| 5815 | 2 | 0 | if (defined $buff and length $buff) | 
 
| 5817 | 2 | 0 | if ($size <= $maxSegmentLen) { } | 
 
| 5820 | 0 | 2 | unless &Write($outfile, $app12hdr, "Ducky", $buff) | 
 
| 5827 | 25 | 463 | if $dirCount{'Adobe'} | 
 
| 5828 | 0 | 463 | if (exists $addDirs->{'Adobe'} and not defined $doneDir{'Adobe'}) | 
 
| 5831 | 0 | 0 | if ($buff) | 
 
| 5832 | 0 | 0 | if $verbose | 
 
| 5834 | 0 | 0 | if ($size <= $maxSegmentLen) { } | 
 
| 5837 | 0 | 0 | unless &Write($outfile, $app14hdr, $buff) | 
 
| 5845 | 20 | 443 | if $dirCount{'COM'} | 
 
| 5846 | 5 | 438 | if (exists $addDirs->{'COM'} and not defined $doneDir{'COM'}) | 
 
| 5848 | 0 | 5 | if $delGroup->{'File'} and $delGroup->{'File'} != 2 | 
 
| 5850 | 5 | 0 | if (defined $newComment) | 
 
| 5851 | 0 | 5 | if ($verbose) | 
 
| 5855 | 0 | 5 | unless &WriteMultiSegment($outfile, 254, "", \$newComment) | 
 
| 5868 | 109 | 687 | if (($marker & 240) == 192 and $marker == 192 || $marker & 3) { } | 
 
|  | 109 | 578 | elsif ($marker == 218) { } | 
 
|  | 2 | 576 | elsif ($marker == 217 and $isEXV) { } | 
 
|  | 0 | 685 | elsif ($marker == 0 or $marker == 1 or $marker >= 208 and $marker <= 215) { } | 
 
| 5869 | 1 | 108 | if $verbose | 
 
| 5870 | 0 | 109 | unless &Write($outfile, $hdr, $segData) | 
 
| 5874 | 1 | 108 | if $verbose | 
 
| 5877 | 0 | 109 | unless &Write($outfile, $hdr, $s, $segData) | 
 
| 5880 | 105 | 4 | unless $delGroup->{'Trailer'} | 
 
| 5882 | 93 | 4 | unless ($oldOutfile or $delPreview or $trailInfo or $delGroup->{'Trailer'} or $nvTrail) | 
 
| 5885 | 0 | 93 | unless &Write($outfile, $buff) | 
 
| 5893 | 0 | 16 | unless my $n = $raf->Read($buff, 65536) | 
 
| 5894 | 16 | 0 | if ($endedWithFF and $buff =~ /^\xd9/gs or $buff =~ /\xff\xd9/gs) | 
 
| 5900 | 0 | 16 | unless &Write($outfile, substr($buff, 0, $pos)) | 
 
| 5904 | 0 | 0 | unless ($n == 65536) | 
 
| 5908 | 0 | 0 | unless &Write($outfile, $buff) | 
 
| 5909 | 0 | 0 | substr($buff, 65535, 1) eq "\377" ? : | 
 
| 5914 | 0 | 16 | if ($nvTrail) | 
 
| 5916 | 0 | 0 | if ($nvTrail->{'Value'} and $nvTrail->{'Value'}[0]) { } | 
 
|  | 0 | 0 | elsif ($raf->Seek(0, 2) and $raf->Tell != $endPos) { } | 
 
| 5918 | 0 | 0 | unless &Write($outfile, $nvTrail->{'Value'}[0]) | 
 
| 5927 | 11 | 5 | if ($trailInfo) | 
 
| 5932 | 0 | 11 | unless $self->ProcessTrailers($trailInfo) | 
 
| 5934 | 15 | 1 | if (not $oldOutfile) { } | 
 
|  | 0 | 1 | elsif ($self->{'LeicaTrailer'}) { } | 
 
| 5938 | 0 | 0 | if ($trailInfo) { } | 
 
| 5941 | 0 | 0 | unless $raf->Seek(0, 2) | 
 
| 5956 | 0 | 0 | defined $dat ? : | 
 
| 5958 | 0 | 0 | if defined $trailSize | 
 
| 5963 | 0 | 0 | unless &Write($outfile, $writeBuffer) | 
 
| 5965 | 0 | 0 | if (defined $dat) | 
 
| 5966 | 0 | 0 | unless &Write($outfile, $dat) | 
 
| 5971 | 0 | 1 | $self->{'Make'} =~ /^SONY/i ? : | 
 
| 5972 | 1 | 0 | if (length $buff < $scanLen) | 
 
| 5974 | 0 | 1 | if $raf->Read($buf2, $scanLen - length($buff)) | 
 
| 5980 | 0 | 1 | if ($buff =~ /(\xff\xd8\xff.|.\xd8\xff\xdb)(..)/gs) | 
 
| 5984 | 0 | 0 | if ($self->{'Make'} =~ /^SONY/i and $junkLen > 32) | 
 
| 5987 | 0 | 0 | if ($jpegHdr eq "\377\330\377\341") | 
 
| 5991 | 0 | 0 | if (length $buff > $junkLen + $segLen + 6 and substr($buff, $junkLen + $segLen + 3, 3) eq "\330\377\333") | 
 
| 6009 | 0 | 1 | if $previewInfo->{'Absolute'} | 
 
| 6010 | 1 | 0 | if ($previewInfo->{'Relative'}) { } | 
 
|  | 0 | 0 | elsif ($previewInfo->{'ChangeBase'}) { } | 
 
| 6016 | 0 | 0 | if $makerOffset | 
 
| 6022 | 0 | 1 | unless &Write($outfile, $writeBuffer) | 
 
| 6025 | 0 | 1 | if ($previewInfo->{'Data'} ne "LOAD_PREVIEW") | 
 
| 6027 | 0 | 0 | if $junkLen | 
 
| 6029 | 0 | 0 | unless &Write($outfile, $previewInfo->{'Data'}) | 
 
| 6036 | 16 | 0 | unless ($delPreview) | 
 
| 6038 | 11 | 5 | if ($trailInfo) { } | 
 
| 6043 | 0 | 5 | unless $raf->Seek(0, 2) | 
 
| 6046 | 3 | 13 | if ($extra > 0) | 
 
| 6047 | 2 | 1 | if ($delGroup->{'Trailer'}) { } | 
 
| 6048 | 0 | 2 | if $verbose | 
 
| 6052 | 0 | 1 | if $verbose | 
 
| 6053 | 0 | 1 | unless $raf->Seek($endPos, 0) | 
 
| 6054 | 0 | 1 | unless &CopyBlock($raf, $outfile, $extra) | 
 
| 6059 | 11 | 5 | if ($trailInfo) | 
 
| 6060 | 0 | 11 | unless $self->WriteTrailerBuffer($trailInfo, $outfile) | 
 
| 6067 | 0 | 2 | unless &Write($outfile, "\377\331") | 
 
| 6072 | 0 | 0 | if $verbose and $marker | 
 
| 6074 | 0 | 0 | unless &Write($outfile, $hdr) | 
 
| 6084 | 2 | 574 | if $verbose | 
 
| 6086 | 55 | 521 | if ($delGroup->{$dirName}) | 
 
| 6087 | 0 | 55 | if $verbose | 
 
| 6088 | 4 | 51 | if $dirName eq "ICC_Profile" | 
 
| 6096 | 31 | 100 | if ($marker == 224) { } | 
 
|  | 73 | 27 | elsif ($marker == 225) { } | 
 
|  | 0 | 27 | elsif ($marker == 226) { } | 
 
|  | 1 | 26 | elsif ($marker == 227) { } | 
 
|  | 0 | 26 | elsif ($marker == 229) { } | 
 
|  | 1 | 25 | elsif ($marker == 236) { } | 
 
|  | 9 | 16 | elsif ($marker == 237) { } | 
 
|  | 4 | 12 | elsif ($marker == 238) { } | 
 
|  | 4 | 8 | elsif ($marker == 254) { } | 
 
| 6097 | 11 | 20 | if ($$segDataPt =~ /^JFIF\0/) { } | 
 
|  | 8 | 12 | elsif ($$segDataPt =~ /^JFXX\0\x10/) { } | 
 
|  | 6 | 6 | elsif ($$segDataPt =~ /^(II|MM).{4}HEAPJPGM/s) { } | 
 
| 6099 | 0 | 11 | if $delGroup->{'JFIF'} | 
 
| 6100 | 0 | 11 | unless $editDirs->{'JFIF'} | 
 
| 6112 | 11 | 0 | if (defined $newData and length $newData) | 
 
| 6117 | 2 | 6 | if $delGroup->{'JFIF'} | 
 
| 6120 | 0 | 6 | if $delGroup->{'CIFF'} | 
 
| 6121 | 2 | 4 | unless $editDirs->{'CIFF'} | 
 
| 6128 | 4 | 0 | if (Image::ExifTool::CanonRaw::WriteCRW($self, \%dirInfo) > 0) | 
 
| 6129 | 4 | 0 | if (length $newData) { } | 
 
| 6139 | 52 | 21 | if ($$segDataPt =~ /^(.{0,4})Exif\0./is) { } | 
 
|  | 21 | 0 | elsif ($$segDataPt =~ /^($Image::ExifTool::xmpAPP1hdr|$Image::ExifTool::xmpExtAPP1hdr)/) { } | 
 
|  | 0 | 0 | elsif ($$segDataPt =~ /^http/ or $$segDataPt =~ / | 
 
| 6141 | 0 | 52 | if (length $1) { } | 
 
|  | 0 | 52 | elsif (not $$segDataPt =~ /^Exif\0/) { } | 
 
| 6148 | 1 | 51 | unless $editDirs->{'IFD0'} | 
 
| 6150 | 0 | 51 | if (defined $combinedSegData) | 
 
| 6157 | 0 | 51 | if ($dirOrder[0] eq "ExtendedEXIF") | 
 
| 6159 | 0 | 0 | unless (defined $combinedSegData) | 
 
| 6166 | 0 | 51 | if $doneDir{'IFD0'} | 
 
| 6169 | 1 | 50 | if ($delGroup->{'IFD0'} or $delGroup->{'EXIF'}) | 
 
| 6186 | 50 | 0 | if (defined $buff) { } | 
 
| 6190 | 0 | 0 | unless $self->Options("IgnoreMinorErrors") | 
 
| 6193 | 4 | 46 | unless length $$segDataPt | 
 
| 6194 | 0 | 46 | if (length($$segDataPt) + length($Image::ExifTool::exifAPP1hdr) > $maxSegmentLen) | 
 
| 6195 | 0 | 0 | if ($self->Options('NoMultiExif')) { } | 
 
| 6202 | 1 | 45 | if ($self->{'PREVIEW_INFO'} || $self->{'LeicaTrailer'} and not $oldOutfile) | 
 
| 6207 | 1 | 0 | if $self->{'PREVIEW_INFO'} | 
 
| 6208 | 0 | 1 | if $self->{'LeicaTrailer'} | 
 
| 6212 | 0 | 46 | if (not $n) { } | 
 
|  | 0 | 92 | elsif ($n > 1 and $oldOutfile) { } | 
 
| 6224 | 0 | 21 | if $delGroup->{'XMP'} | 
 
| 6226 | 7 | 14 | unless $editDirs->{'XMP'} | 
 
| 6227 | 3 | 11 | if ($doneDir{'XMP'} + $dirCount{'XMP'} > 1) | 
 
| 6230 | 2 | 1 | if ($$segDataPt =~ /^$Image::ExifTool::xmpExtAPP1hdr/) { } | 
 
| 6232 | 0 | 2 | if (length $$segDataPt < 75) { } | 
 
| 6237 | 0 | 2 | if ($guid =~ /[^A-Za-z0-9]/) { } | 
 
| 6242 | 1 | 1 | if ($extXMP) { } | 
 
| 6243 | 0 | 1 | unless $size == $extXMP->{'Size'} | 
 
| 6253 | 1 | 0 | unless $extendedXMP{'Main'} | 
 
| 6257 | 2 | 1 | if $dirCount{'XMP'} | 
 
| 6263 | 1 | 0 | if (/:HasExtendedXMP\s*(=\s*['"]|>)(\w{32})/) | 
 
| 6266 | 0 | 1 | if ($goodGuid and $goodGuid ne $2) | 
 
| 6275 | 1 | 0 | if $readGuid eq 1 | 
 
| 6277 | 1 | 1 | unless length $guid == 32 | 
 
| 6278 | 0 | 1 | if ($guid ne $readGuid and $readGuid ne 2) | 
 
| 6279 | 0 | 0 | $guid eq $goodGuid ? : | 
 
| 6283 | 0 | 1 | if ($guid ne $goodGuid) | 
 
| 6287 | 0 | 1 | unless ref $extXMP eq "HASH" | 
 
| 6291 | 0 | 2 | unless defined $extXMP->{$off} | 
 
| 6295 | 1 | 0 | if ($off == $size) { } | 
 
| 6302 | 0 | 1 | if $extendedXMP{'Error'} | 
 
| 6314 | 9 | 3 | if (defined $newData) { } | 
 
| 6316 | 7 | 2 | if (length $newData) { } | 
 
| 6319 | 0 | 7 | unless &WriteMultiXMP($self, $outfile, \$newData, $dirInfo{'ExtendedXMP'}, $dirInfo{'ExtendedGUID'}) | 
 
| 6326 | 0 | 3 | if $verbose | 
 
| 6327 | 0 | 3 | if ($doneDir{'XMP'} > 1) | 
 
| 6331 | 0 | 0 | unless length $dat | 
 
| 6333 | 0 | 0 | unless &Write($outfile, $hdr, $s, $Image::ExifTool::xmpAPP1hdr, $dat) | 
 
| 6336 | 0 | 0 | unless length $guid == 32 | 
 
| 6338 | 0 | 0 | unless ref $extXMP eq "HASH" | 
 
| 6339 | 0 | 0 | unless my $size = $extXMP->{'Size'} | 
 
| 6343 | 0 | 0 | unless &Write($outfile, $hdr, $s, $Image::ExifTool::xmpExtAPP1hdr, $guid, pack("N2", $size, $off), $extXMP->{$off}) | 
 
| 6352 | 2 | 3 | unless length $$segDataPt | 
 
| 6357 | 0 | 0 | if ($$segDataPt =~ /^ICC_PROFILE\0/ and $length >= 14) { } | 
 
|  | 0 | 0 | elsif ($$segDataPt =~ /^FPXR\0/) { } | 
 
|  | 0 | 0 | elsif ($$segDataPt =~ /^MPF\0/) { } | 
 
| 6359 | 0 | 0 | if $delGroup->{'ICC_Profile'} | 
 
| 6363 | 0 | 0 | if (defined $iccChunksTotal) { } | 
 
| 6365 | 0 | 0 | if ($chunksTot != $iccChunksTotal and defined $iccChunkCount) | 
 
| 6375 | 0 | 0 | unless $chunksTot | 
 
| 6377 | 0 | 0 | if (defined $iccChunkCount) { } | 
 
|  | 0 | 0 | elsif (defined $chunkNum) { } | 
 
| 6379 | 0 | 0 | if (defined $iccChunk[$chunkNum]) { } | 
 
| 6386 | 0 | 0 | unless ++$iccChunkCount >= $iccChunksTotal | 
 
| 6405 | 0 | 0 | if (defined $newData) | 
 
| 6409 | 0 | 0 | unless length $$segDataPt | 
 
| 6411 | 0 | 0 | unless &WriteMultiSegment($outfile, $marker, "ICC_PROFILE\0", $segDataPt, "ICC") | 
 
| 6420 | 0 | 0 | if $delGroup->{'FlashPix'} | 
 
| 6423 | 0 | 0 | if $delGroup->{'MPF'} | 
 
| 6426 | 1 | 0 | if ($$segDataPt =~ /^(Meta|META|Exif)\0\0/) | 
 
| 6428 | 0 | 1 | if $delGroup->{'Meta'} | 
 
| 6429 | 0 | 1 | if $doneDir{'Meta'} | 
 
| 6431 | 0 | 1 | unless $editDirs->{'Meta'} | 
 
| 6444 | 1 | 0 | if (defined $buff) { } | 
 
| 6448 | 0 | 0 | unless $self->Options("IgnoreMinorErrors") | 
 
| 6451 | 0 | 1 | unless length $$segDataPt > 6 | 
 
| 6454 | 0 | 0 | if ($$segDataPt =~ /^RMETA\0/) | 
 
| 6456 | 0 | 0 | if $delGroup->{'RMETA'} | 
 
| 6459 | 1 | 0 | if ($$segDataPt =~ /^Ducky/) | 
 
| 6461 | 0 | 1 | if $delGroup->{'Ducky'} | 
 
| 6462 | 0 | 1 | if $doneDir{'Ducky'} | 
 
| 6464 | 0 | 1 | unless $editDirs->{'Ducky'} | 
 
| 6475 | 1 | 0 | if (defined $newData) | 
 
| 6478 | 0 | 1 | if length $newData | 
 
| 6481 | 1 | 0 | unless length $$segDataPt | 
 
| 6484 | 8 | 1 | if ($$segDataPt =~ /^$Image::ExifTool::psAPP13hdr/) | 
 
| 6487 | 0 | 8 | if (defined $combinedSegData) | 
 
| 6493 | 0 | 8 | if ($dirOrder[0] eq "Photoshop") | 
 
| 6495 | 0 | 0 | unless defined $combinedSegData | 
 
| 6498 | 0 | 8 | if ($doneDir{'Photoshop'}) | 
 
| 6502 | 0 | 0 | if $delGroup->{'Photoshop'} | 
 
| 6516 | 8 | 0 | if (defined $newData) | 
 
| 6520 | 2 | 6 | unless length $$segDataPt | 
 
| 6522 | 0 | 6 | unless &WriteMultiSegment($outfile, $marker, $Image::ExifTool::psAPP13hdr, $segDataPt) | 
 
| 6528 | 4 | 0 | if ($$segDataPt =~ /^Adobe/) | 
 
| 6531 | 0 | 4 | if ($delGroup->{'Adobe'} or $editDirs->{'Adobe'}) | 
 
| 6538 | 4 | 0 | unless ($doneDir{'COM'}) | 
 
| 6540 | 3 | 1 | unless ($delGroup->{'File'} and $delGroup->{'File'} != 2) | 
 
| 6545 | 3 | 0 | if ($self->IsOverwriting($nvHash, $val) or $delGroup->{'File'}) { } | 
 
| 6554 | 2 | 2 | if (defined $newComment) { } | 
 
| 6557 | 0 | 2 | unless &WriteMultiSegment($outfile, 254, "", \$newComment) | 
 
| 6559 | 0 | 2 | if $verbose | 
 
| 6568 | 13 | 10 | if ($del or $delGroup->{'*'} and not $segType and $marker >= 224 and $marker <= 239) | 
 
| 6569 | 1 | 12 | unless $segType | 
 
| 6570 | 0 | 13 | if $verbose | 
 
| 6575 | 443 | 4 | if (defined $segDataPt and defined $$segDataPt) | 
 
| 6579 | 0 | 443 | if ($size > $maxSegmentLen) { } | 
 
| 6580 | 0 | 0 | unless $segType | 
 
| 6585 | 0 | 443 | unless &Write($outfile, $hdr, $s, $$segDataPt) | 
 
| 6592 | 0 | 111 | if defined $iccChunkCount | 
 
| 6593 | 2 | 109 | if @$path > $pn | 
 
| 6595 | 0 | 111 | if $oldOutfile | 
 
| 6596 | 111 | 0 | if ($rtnVal) | 
 
| 6599 | 3 | 108 | if $trailPt | 
 
| 6602 | 0 | 111 | if $rtnVal and $err | 
 
| 6603 | 0 | 1 | if ($creatingEXV and $rtnVal > 0 and not $self->{'CHANGED'}) | 
 
| 6617 | 25 | 66 | if (length $$valPtr and not $$valPtr =~ /^\xff\xd8/ and not $self->Options("IgnoreMinorErrors")) | 
 
| 6636 | 2487 | 16688 | if ($format eq "string" or $format eq "undef") | 
 
| 6637 | 2186 | 301 | unless $count and $count > 0 | 
 
| 6639 | 198 | 103 | if ($format eq 'string') { } | 
 
| 6640 | 10 | 188 | if $len >= $count | 
 
| 6642 | 0 | 103 | if $len > $count | 
 
| 6644 | 232 | 59 | if ($len < $count) | 
 
| 6649 | 1923 | 14765 | if ($count and $count != 1) { } | 
 
| 6651 | 127 | 1796 | if $count < 0 | 
 
| 6656 | 913 | 15756 | if (@vals != $count) | 
 
| 6657 | 3 | 910 | @vals > $count ? : | 
 
| 6662 | 17349 | 1354 | if ($format =~ /^int/) { } | 
 
|  | 1351 | 3 | elsif ($format =~ /^rational/ or $format eq 'float' or $format eq 'double') { } | 
 
| 6664 | 3032 | 14317 | unless (&IsInt($val)) | 
 
| 6665 | 7 | 3025 | if (&IsHex($val)) { } | 
 
| 6669 | 1758 | 1267 | unless &IsFloat($val) and $count == 1 | 
 
| 6670 | 20 | 1247 | $val < 0 ? : | 
 
| 6673 | 0 | 15591 | unless my $rng = $intRange{$format} | 
 
| 6674 | 301 | 15290 | if $val < $rng->[0] | 
 
| 6676 | 4 | 15286 | if $val > $rng->[1] and $val != 4277010157 | 
 
| 6679 | 268 | 1083 | unless (&IsFloat($val)) | 
 
| 6681 | 232 | 36 | if ($format =~ /^rational/) | 
 
| 6682 | 1 | 231 | if $val eq "inf" or $val eq "undef" | 
 
| 6683 | 70 | 161 | if ($val =~ m[^([-+]?\d+)/(\d+)$]) | 
 
| 6684 | 70 | 0 | unless $1 < 0 and $format =~ /u$/ | 
 
| 6690 | 0 | 1083 | if ($format =~ /^rational\d+u$/ and $val < 0) | 
 
| 6706 | 4426 | 7350 | unless ($format) | 
 
| 6708 | 3111 | 1315 | if ($table and $table->{'FORMAT'}) { } | 
 
| 6716 | 1637 | 10139 | if ($format =~ /(.*)\[(.*)\]/) | 
 
| 6720 | 0 | 1637 | if $count =~ /\$size/ | 
 
| 6734 | 0 | 3 | if ($self->EncodeFileName($old)) { } | 
 
|  | 0 | 3 | elsif ($self->EncodeFileName($new)) { } | 
 
| 6743 | 0 | 3 | if ($winUni) { } | 
 
| 6750 | 3 | 0 | if $result or $^O ne "MSWin32" | 
 
| 6754 | 0 | 0 | if $try > 50 | 
 
| 6770 | 0 | 0 | if ($self->EncodeFileName($file)) { } | 
 
| 6771 | 0 | 0 | if eval {
	do {
	Win32API::File::DeleteFileW($file)
}
} | 
 
| 6773 | 0 | 0 | if unlink $file | 
 
| 6793 | 0 | 0 | unless (ref $file) | 
 
| 6795 | 0 | 0 | unless ($self->Open(\*FH, $file, "+<")) | 
 
| 6797 | 0 | 0 | if (defined $atime or defined $mtime) | 
 
| 6799 | 0 | 0 | unless defined $atime | 
 
| 6800 | 0 | 0 | unless defined $mtime | 
 
| 6801 | 0 | 0 | if defined $atime and defined $mtime | 
 
| 6803 | 0 | 0 | unless $success | 
 
| 6810 | 0 | 0 | if ($^O eq "MSWin32") | 
 
| 6811 | 0 | 0 | if (not eval {
	do {
	require Win32::API
}
}) { } | 
 
|  | 0 | 0 | elsif (not eval {
	do {
	require Win32API::File
}
}) { } | 
 
| 6818 | 0 | 0 | unless ($win32Handle) | 
 
| 6826 | 0 | 0 | unless defined $time | 
 
| 6833 | 0 | 0 | unless ($k32SetFileTime) | 
 
| 6834 | 0 | 0 | if defined $k32SetFileTime | 
 
| 6836 | 0 | 0 | unless ($k32SetFileTime) | 
 
| 6842 | 0 | 0 | unless ($k32SetFileTime->Call($win32Handle, $ctime, $atime, $mtime)) | 
 
| 6850 | 0 | 0 | if (defined $atime and defined $mtime) | 
 
| 6857 | 0 | 0 | if $success or not defined $saveFile | 
 
| 6862 | 0 | 0 | unless ($noWarn) | 
 
| 6863 | 0 | 0 | if ($@ or $Image::ExifTool::evalWarning) { } | 
 
|  | 0 | 0 | elsif (not $success) { } | 
 
| 6882 | 1 | 0 | unless my $md5 = $self->{'ImageDataMD5'} | 
 
| 6886 | 0 | 0 | if (defined $size) | 
 
| 6887 | 0 | 0 | unless $size | 
 
| 6888 | 0 | 0 | $size > 65536 ? : | 
 
| 6891 | 0 | 0 | unless ($raf->Read($buff, $n)) | 
 
| 6892 | 0 | 0 | if $type and defined $size | 
 
| 6898 | 0 | 0 | if ($self->{'OPTIONS'}{'Verbose'} and $bytesRead and $type and not $noMsg) | 
 
| 6913 | 69 | 53 | unless $size > 0 | 
 
| 6914 | 0 | 53 | $size > 65536 ? : | 
 
| 6915 | 0 | 53 | unless $raf->Read($buff, $n) == $n | 
 
| 6916 | 0 | 53 | unless &Write($outfile, $buff) | 
 
| 6934 | 13 | 0 | if $num | 
 
| 6937 | 0 | 24 | unless $raf->Seek($pos, 0) | 
 
| 6939 | 0 | 0 | defined $result ? : | 
 
|  | 0 | 24 | unless $result | 
 
| 6941 | 3 | 21 | if $pad | 
 
| 6942 | 0 | 24 | if $err | 
 
| 6944 | 0 | 13 | if ($err) | 
 
| 6958 | 14552 | 458 | unless $self | 
 
| 6961 | 0 | 458 | unless my $dataPt = $dirInfo->{'DataPt'} | 
 
| 6965 | 0 | 458 | unless ($increment) | 
 
| 6971 | 195 | 263 | if ($tagTablePtr->{'DATAMEMBER'}) | 
 
| 6980 | 1 | 457 | if not defined $dirLen or $dirLen > $dataLen - $dirStart | 
 
| 6981 | 0 | 458 | unless my $newData = substr($$dataPt, $dirStart, $dirLen) | 
 
| 6990 | 22 | 205 | if (ref $tagTablePtr->{$tagID} eq "ARRAY" or $tagInfo->{'Condition'}) | 
 
| 6992 | 9 | 13 | unless $writeInfo and $writeInfo eq $tagInfo | 
 
| 7002 | 87 | 131 | if ($format) { } | 
 
| 7003 | 36 | 51 | if ($format =~ /(.*)\[(.*)\]/) { } | 
 
|  | 1 | 50 | elsif ($format eq 'string') { } | 
 
| 7010 | 0 | 36 | if $@ | 
 
| 7013 | 1 | 0 | $dirLen > $entry ? : | 
 
| 7019 | 6 | 212 | if @varInfo and $varInfo[0][0] == $tagID | 
 
| 7021 | 3 | 215 | unless defined $val | 
 
| 7023 | 1 | 214 | unless $self->IsOverwriting($nvHash, $val) > 0 | 
 
| 7025 | 1 | 213 | unless defined $newVal | 
 
| 7027 | 6 | 207 | if $tagInfo->{'DataMember'} | 
 
| 7030 | 1 | 212 | if $mask | 
 
| 7032 | 0 | 213 | if ($tagInfo->{'DataTag'} and not $tagInfo->{'IsOffset'}) | 
 
| 7033 | 0 | 0 | unless $newVal == 4277010157 | 
 
| 7035 | 0 | 0 | if defined $data | 
 
| 7037 | 0 | 0 | if ($format =~ /^int16/ and $newVal > 65535) | 
 
| 7042 | 213 | 0 | if (defined $rtnVal) | 
 
| 7049 | 1 | 0 | if ($tagTablePtr->{'IS_OFFSET'} and $dirInfo->{'Fixup'}) | 
 
| 7055 | 0 | 1 | unless $tagInfo = $self->GetTagInfo($tagTablePtr, $tagID) | 
 
| 7061 | 1 | 0 | unless $entry <= $dirLen - 4 | 
 
| 7066 | 0 | 0 | unless $offset | 
 
| 7070 | 0 | 0 | unless $self->{'FILE_TYPE'} eq "JPEG" and $tagInfo->{'DataTag'} and $tagInfo->{'DataTag'} eq "PreviewImage" and defined $tagInfo->{'OffsetPair'} | 
 
| 7078 | 0 | 0 | unless $previewInfo | 
 
| 7081 | 0 | 0 | unless $format eq "int32u" | 
 
| 7082 | 0 | 0 | if $tagInfo->{'IsOffset'} and $tagInfo->{'IsOffset'} eq 3 | 
 
| 7085 | 0 | 0 | unless (defined $previewInfo->{'Data'}) | 
 
| 7086 | 0 | 0 | if ($offset >= 0 and $offset + $size <= $dirInfo->{'DataLen'}) { } | 
 
| 7095 | 12 | 446 | if ($tagTablePtr->{'IS_SUBDIR'}) | 
 
| 7101 | 9 | 4 | unless defined $tagInfo | 
 
| 7107 | 0 | 4 | if $entry >= $dirLen | 
 
| 7109 | 0 | 4 | unless ($tagInfo) | 
 
| 7111 | 0 | 0 | if $more > 128 | 
 
| 7114 | 0 | 0 | unless $tagInfo | 
 
| 7116 | 0 | 4 | unless my $subdir = $tagInfo->{'SubDirectory'} | 
 
| 7119 | 4 | 0 | if (not $start) { } | 
 
|  | 0 | 0 | elsif ($start =~ /\$/) { } | 
 
| 7125 | 0 | 0 | if $format =~ /(.*)\[(.*)\]/ | 
 
| 7128 | 0 | 0 | unless $val | 
 
| 7132 | 0 | 0 | if $start < $dirStart or $start > $dataLen | 
 
| 7134 | 0 | 0 | unless $len and $len <= $dataLen - $start | 
 
| 7143 | 4 | 0 | if defined $dat and length $dat | 
 
| 7156 | 0 | 111 | unless $self | 
 
| 7159 | 111 | 0 | if $self->ProcessTIFF($dirInfo, $tagTablePtr) > 0 |