Changeset 34921 for main/trunk/greenstone2/perllib/cpan/Image/ExifTool/EXE.pm

Timestamp:

2021-02-26T19:39:51+13:00 (3 years ago)

Author:

anupama

Message:

Committing the improvements to EmbeddedMetaPlugin's processing of Keywords vs other metadata fields. Keywords were literally stored as arrays of words rather than phrases in PDFs (at least in Diego's sample PDF), whereas other meta fields like Subjects and Creators stored them as arrays of phrases. To get both to work, Kathy updated EXIF to a newer version, to retrieve the actual EXIF values stored in the PDF. And Kathy and Dr Bainbridge came up with a new option that I added called apply_join_before_split_to_metafields that's a regex which can list the metadata fields to apply the join_before_split to and whcih previously always got applied to all metadata fields. Now it's applied to any *Keywords metafields by default, as that's the metafield we have experience of that behaves differently to the others, as it stores by word instead of phrases. Tested on Diego's sample PDF. Diego has double-checked it to works on his sample PDF too, setting the split char to ; and turning on the join_before_split and leaving apply_join_before_split_to_metafields at its default of .*Keywords. File changes are strings.properties for the tooltip, the plugin introducing the option and working with it and Kathy's EXIF updates affecting cpan/File and cpan/Image.

File:

• main/trunk/greenstone2/perllib/cpan/Image/ExifTool/EXE.pm (modified) (39 diffs)

main/trunk/greenstone2/perllib/cpan/Image/ExifTool/EXE.pm

@@ -5 +5 @@
 #
 # Revisions:    2008/08/28 - P. Harvey Created
+#               2011/07/12 - P. Harvey Added CHM (ok, not EXE, but it fits here)
 #
 # References:   1) http://www.openwatcom.org/ftp/devel/docs/pecoff.pdf
@@ -21 +22 @@
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.04';
+$VERSION = '1.17';
 
 sub ProcessPEResources($$);
@@ -49 +50 @@
     23 => 'HTML',
     24 => 'Manifest',
+);
+
+my %languageCode = (
+    Notes => q{
+        See L<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid>
+        for the full list of Microsoft language codes.
+    },
+    '0000' => 'Neutral',
+    '007F' => 'Invariant',
+    '0400' => 'Process default',
+    '0401' => 'Arabic',
+    '0402' => 'Bulgarian',
+    '0403' => 'Catalan',
+    '0404' => 'Chinese (Traditional)',
+    '0405' => 'Czech',
+    '0406' => 'Danish',
+    '0407' => 'German',
+    '0408' => 'Greek',
+    '0409' => 'English (U.S.)',
+    '040A' => 'Spanish (Castilian)',
+    '040B' => 'Finnish',
+    '040C' => 'French',
+    '040D' => 'Hebrew',
+    '040E' => 'Hungarian',
+    '040F' => 'Icelandic',
+    '0410' => 'Italian',
+    '0411' => 'Japanese',
+    '0412' => 'Korean',
+    '0413' => 'Dutch',
+    '0414' => 'Norwegian (Bokml)',
+    '0415' => 'Polish',
+    '0416' => 'Portuguese (Brazilian)',
+    '0417' => 'Rhaeto-Romanic',
+    '0418' => 'Romanian',
+    '0419' => 'Russian',
+    '041A' => 'Croato-Serbian (Latin)',
+    '041B' => 'Slovak',
+    '041C' => 'Albanian',
+    '041D' => 'Swedish',
+    '041E' => 'Thai',
+    '041F' => 'Turkish',
+    '0420' => 'Urdu',
+    # 0421-0493 ref 6
+    '0421' => 'Indonesian',
+    '0422' => 'Ukrainian',
+    '0423' => 'Belarusian',
+    '0424' => 'Slovenian',
+    '0425' => 'Estonian',
+    '0426' => 'Latvian',
+    '0427' => 'Lithuanian',
+    '0428' => 'Maori',
+    '0429' => 'Farsi',
+    '042a' => 'Vietnamese',
+    '042b' => 'Armenian',
+    '042c' => 'Azeri',
+    '042d' => 'Basque',
+    '042e' => 'Sorbian',
+    '042f' => 'Macedonian',
+    '0430' => 'Sutu',
+    '0431' => 'Tsonga',
+    '0432' => 'Tswana',
+    '0433' => 'Venda',
+    '0434' => 'Xhosa',
+    '0435' => 'Zulu',
+    '0436' => 'Afrikaans',
+    '0437' => 'Georgian',
+    '0438' => 'Faeroese',
+    '0439' => 'Hindi',
+    '043a' => 'Maltese',
+    '043b' => 'Saami',
+    '043c' => 'Gaelic',
+    '043e' => 'Malay',
+    '043f' => 'Kazak',
+    '0440' => 'Kyrgyz',
+    '0441' => 'Swahili',
+    '0443' => 'Uzbek',
+    '0444' => 'Tatar',
+    '0445' => 'Bengali',
+    '0446' => 'Punjabi',
+    '0447' => 'Gujarati',
+    '0448' => 'Oriya',
+    '0449' => 'Tamil',
+    '044a' => 'Telugu',
+    '044b' => 'Kannada',
+    '044c' => 'Malayalam',
+    '044d' => 'Assamese',
+    '044e' => 'Marathi',
+    '044f' => 'Sanskrit',
+    '0450' => 'Mongolian',
+    '0456' => 'Galician',
+    '0457' => 'Konkani',
+    '0458' => 'Manipuri',
+    '0459' => 'Sindhi',
+    '045a' => 'Syriac',
+    '0460' => 'Kashmiri',
+    '0461' => 'Nepali',
+    '0465' => 'Divehi',
+    '047f' => 'Invariant',
+    '048f' => 'Esperanto',
+    '0490' => 'Walon',
+    '0491' => 'Cornish',
+    '0492' => 'Welsh',
+    '0493' => 'Breton',
+    '0800' => 'Neutral 2',
+    '0804' => 'Chinese (Simplified)',
+    '0807' => 'German (Swiss)',
+    '0809' => 'English (British)',
+    '080A' => 'Spanish (Mexican)',
+    '080C' => 'French (Belgian)',
+    '0810' => 'Italian (Swiss)',
+    '0813' => 'Dutch (Belgian)',
+    '0814' => 'Norwegian (Nynorsk)',
+    '0816' => 'Portuguese',
+    '081A' => 'Serbo-Croatian (Cyrillic)',
+    '0C07' => 'German (Austrian)',
+    '0C09' => 'English (Australian)',
+    '0C0A' => 'Spanish (Modern)',
+    '0C0C' => 'French (Canadian)',
+    '1009' => 'English (Canadian)',
+    '100C' => 'French (Swiss)',
 );
 
@@ -102 +223 @@
         PrintConv => '$self->ConvertDateTime($val)',
     },
+    9 => {
+        Name => 'ImageFileCharacteristics',
+        # ref https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_image_file_header
+        PrintConv => { BITMASK => {
+            0 => 'No relocs',
+            1 => 'Executable',
+            2 => 'No line numbers',
+            3 => 'No symbols',
+            4 => 'Aggressive working-set trim',
+            5 => 'Large address aware',
+            7 => 'Bytes reversed lo',
+            8 => '32-bit',
+            9 => 'No debug',
+            10 => 'Removable run from swap',
+            11 => 'Net run from swap',
+            12 => 'System file',
+            13 => 'DLL',
+            14 => 'Uniprocessor only',
+            15 => 'Bytes reversed hi',
+        }},
+    },
     10 => {
         Name => 'PEType',
         PrintHex => 1,
         PrintConv => {
+            0x107 => 'ROM Image',
             0x10b => 'PE32',
             0x20b => 'PE32+',
@@ -154 +297 @@
             2 => 'Windows GUI',
             3 => 'Windows command line',
-            5 => 'OS/2 Command line', #5
+            5 => 'OS/2 command line', #5
             7 => 'POSIX command line',
             9 => 'Windows CE GUI',
@@ -259 +402 @@
     },
     LanguageCode => {
-        Notes => 'extracted from the StringFileInfo value',
+        Notes => 'Windows code page; extracted from the StringFileInfo value',
         # ref http://techsupt.winbatch.com/TS/T000001050F49.html
         # (also see http://support.bigfix.com/fixlet/documents/WinInspectors-2006-08-10.pdf)
@@ -265 +408 @@
         # (not a complete set)
         PrintString => 1,
-        PrintConv => {
-            '0000' => 'Neutral',
-            '007F' => 'Invariant',
-            '0400' => 'Process default',
-            '0401' => 'Arabic',
-            '0402' => 'Bulgarian',
-            '0403' => 'Catalan',
-            '0404' => 'Chinese (Traditional)',
-            '0405' => 'Czech',
-            '0406' => 'Danish',
-            '0407' => 'German',
-            '0408' => 'Greek',
-            '0409' => 'English (U.S.)',
-            '040A' => 'Spanish (Castilian)',
-            '040B' => 'Finnish',
-            '040C' => 'French',
-            '040D' => 'Hebrew',
-            '040E' => 'Hungarian',
-            '040F' => 'Icelandic',
-            '0410' => 'Italian',
-            '0411' => 'Japanese',
-            '0412' => 'Korean',
-            '0413' => 'Dutch',
-            '0414' => 'Norwegian (Bokml)',
-            '0415' => 'Polish',
-            '0416' => 'Portuguese (Brazilian)',
-            '0417' => 'Rhaeto-Romanic',
-            '0418' => 'Romanian',
-            '0419' => 'Russian',
-            '041A' => 'Croato-Serbian (Latin)',
-            '041B' => 'Slovak',
-            '041C' => 'Albanian',
-            '041D' => 'Swedish',
-            '041E' => 'Thai',
-            '041F' => 'Turkish',
-            '0420' => 'Urdu',
-            # 0421-0493 ref 6
-            '0421' => 'Indonesian',
-            '0422' => 'Ukrainian',
-            '0423' => 'Belarusian',
-            '0424' => 'Slovenian',
-            '0425' => 'Estonian',
-            '0426' => 'Latvian',
-            '0427' => 'Lithuanian',
-            '0428' => 'Maori',
-            '0429' => 'Farsi',
-            '042a' => 'Vietnamese',
-            '042b' => 'Armenian',
-            '042c' => 'Azeri',
-            '042d' => 'Basque',
-            '042e' => 'Sorbian',
-            '042f' => 'Macedonian',
-            '0430' => 'Sutu',
-            '0431' => 'Tsonga',
-            '0432' => 'Tswana',
-            '0433' => 'Venda',
-            '0434' => 'Xhosa',
-            '0435' => 'Zulu',
-            '0436' => 'Afrikaans',
-            '0437' => 'Georgian',
-            '0438' => 'Faeroese',
-            '0439' => 'Hindi',
-            '043a' => 'Maltese',
-            '043b' => 'Saami',
-            '043c' => 'Gaelic',
-            '043e' => 'Malay',
-            '043f' => 'Kazak',
-            '0440' => 'Kyrgyz',
-            '0441' => 'Swahili',
-            '0443' => 'Uzbek',
-            '0444' => 'Tatar',
-            '0445' => 'Bengali',
-            '0446' => 'Punjabi',
-            '0447' => 'Gujarati',
-            '0448' => 'Oriya',
-            '0449' => 'Tamil',
-            '044a' => 'Telugu',
-            '044b' => 'Kannada',
-            '044c' => 'Malayalam',
-            '044d' => 'Assamese',
-            '044e' => 'Marathi',
-            '044f' => 'Sanskrit',
-            '0450' => 'Mongolian',
-            '0456' => 'Galician',
-            '0457' => 'Konkani',
-            '0458' => 'Manipuri',
-            '0459' => 'Sindhi',
-            '045a' => 'Syriac',
-            '0460' => 'Kashmiri',
-            '0461' => 'Nepali',
-            '0465' => 'Divehi',
-            '047f' => 'Invariant',
-            '048f' => 'Esperanto',
-            '0490' => 'Walon',
-            '0491' => 'Cornish',
-            '0492' => 'Welsh',
-            '0493' => 'Breton',
-            '0800' => 'Neutral 2',
-            '0804' => 'Chinese (Simplified)',
-            '0807' => 'German (Swiss)',
-            '0809' => 'English (British)',
-            '080A' => 'Spanish (Mexican)',
-            '080C' => 'French (Belgian)',
-            '0810' => 'Italian (Swiss)',
-            '0813' => 'Dutch (Belgian)',
-            '0814' => 'Norwegian (Nynorsk)',
-            '0816' => 'Portuguese',
-            '081A' => 'Serbo-Croatian (Cyrillic)',
-            '0C07' => 'German (Austrian)',
-            '0C09' => 'English (Australian)',
-            '0C0A' => 'Spanish (Modern)',
-            '0C0C' => 'French (Canadian)',
-            '1009' => 'English (Canadian)',
-            '100C' => 'French (Swiss)',
-        },
+        SeparateTable => 1,
+        PrintConv => \%languageCode,
     },
     CharacterSet => {
@@ -412 +442 @@
     LegalCopyright  => { },
     LegalTrademarks => { },
-    OriginalFilename=> { },
+    OriginalFilename=> { Name => 'OriginalFileName' },
     PrivateBuild    => { },
     ProductName     => { },
@@ -595 +625 @@
             8 => 'Dynamically bound bundle',
             9 => 'Shared library stub for static linking',
+            # (the following from Apple loader.h header file)
+            10 => 'Debug information',
+            11 => 'x86_64 kexts',
         },
+    },
+    6 => {
+        Name => 'ObjectFlags',
+        PrintHex => 1,
+        # ref Apple loader.h header file
+        PrintConv => { BITMASK => {
+             0 => 'No undefs',
+             1 => 'Incrementa link',
+             2 => 'Dyld link',
+             3 => 'Bind at load',
+             4 => 'Prebound',
+             5 => 'Split segs',
+             6 => 'Lazy init',
+             7 => 'Two level',
+             8 => 'Force flat',
+             9 => 'No multi defs',
+             10 => 'No fix prebinding',
+             11 => 'Prebindable',
+             12 => 'All mods bound',
+             13 => 'Subsections via symbols',
+             14 => 'Canonical',
+             15 => 'Weak defines',
+             16 => 'Binds to weak',
+             17 => 'Allow stack execution',
+             18 => 'Dead strippable dylib',
+             19 => 'Root safe',
+             20 => 'No reexported dylibs',
+             21 => 'Random address',
+        }},
     },
 );
@@ -699 +761 @@
 );
 
+# Information extracted from static library archives
+# (ref http://opensource.apple.com//source/xnu/xnu-1456.1.26/EXTERNAL_HEADERS/ar.h)
+%Image::ExifTool::EXE::AR = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Other' },
+    NOTES => q{
+        Information extracted from static libraries.
+    },
+  #  0  string[16] ar_name
+    16 => {
+        Name => 'CreateDate',
+        Groups => { 2 => 'Time' },
+        Format => 'string[12]',
+        ValueConv => 'ConvertUnixTime($val,1)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+  # 28  string[6]  ar_uid
+  # 34  string[6]  ar_gid
+  # 40  string[8]  ar_mode
+  # 48  string[10] ar_size
+  # 58  string[2]  terminator "`\n"
+);
+
+# Microsoft compiled help format (ref http://www.russotto.net/chm/chmformat.html)
+%Image::ExifTool::EXE::CHM = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Other' },
+    NOTES => 'Tags extracted from Microsoft Compiled HTML files.',
+    FORMAT => 'int32u',
+    1 => { Name => 'CHMVersion' },
+    # 2 - total header length
+    # 3 - 1
+    # 4 - low bits of date/time value plus 42 (ref http://www.nongnu.org/chmspec/latest/ITSF.html)
+    5 => {
+        Name => 'LanguageCode',
+        SeparateTable => 1,
+        ValueConv => 'sprintf("%.4X", $val)',
+        PrintConv => \%languageCode,
+    },
+);
+
+#------------------------------------------------------------------------------
+# Extract information from a CHM file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid CHM file
+sub ProcessCHM($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    return 0 unless $raf->Read($buff, 56) == 56 and
+        $buff =~ /^ITSF.{20}\x10\xfd\x01\x7c\xaa\x7b\xd0\x11\x9e\x0c\0\xa0\xc9\x22\xe6\xec/s;
+    my $tagTablePtr = GetTagTable('Image::ExifTool::EXE::CHM');
+    $et->SetFileType();
+    SetByteOrder('II');
+    $et->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Read Unicode string (null terminated) from resource
-# Inputs: 0) data ref, 1) start offset, 2) optional ExifTool object ref
+# Inputs: 0) data ref, 1) start offset, 2) data end, 3) optional ExifTool object ref
 # Returns: 0) Unicode string translated to UTF8, or current CharSet with ExifTool ref
 #          1) end pos (rounded up to nearest 4 bytes)
-sub ReadUnicodeStr($$;$)
+sub ReadUnicodeStr($$$;$)
 {
-    my ($dataPt, $pos, $exifTool) = @_;
-    my $len = length $$dataPt;
+    my ($dataPt, $pos, $end, $et) = @_;
+    $end = length $$dataPt if $end > length $$dataPt;   # (be safe)
     my $str = '';
-    while ($pos + 2 <= $len) {
+    while ($pos + 2 <= $end) {
         my $ch = substr($$dataPt, $pos, 2);
         $pos += 2;
@@ -716 +838 @@
     }
     $pos += 2 if $pos & 0x03;
-    my $to = $exifTool ? $exifTool->Options('Charset') : 'UTF8';
+    my $to = $et ? $et->Options('Charset') : 'UTF8';
     return (Image::ExifTool::Decode(undef,$str,'UCS2','II',$to), $pos);
 }
@@ -726 +848 @@
 sub ProcessPEVersion($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $pos = $$dirInfo{DirStart};
@@ -740 +862 @@
         $type = Get16u($dataPt, $pos + 4);
         return 0 unless $len or $valLen;  # prevent possible infinite loop
-        ($string, $strEnd) = ReadUnicodeStr($dataPt, $pos + 6);
+        ($string, $strEnd) = ReadUnicodeStr($dataPt, $pos + 6, $pos + $len);
         return 0 if $strEnd + $valLen > $end;
         unless ($index or $string eq 'VS_VERSION_INFO') {
-            $exifTool->Warn('Invalid Version Info block');
+            $et->Warn('Invalid Version Info block');
             return 0;
         }
@@ -751 +873 @@
             $$dirInfo{DirLen} = $valLen;
             my $subTablePtr = GetTagTable('Image::ExifTool::EXE::PEVersion');
-            $exifTool->ProcessDirectory($dirInfo, $subTablePtr);
+            $et->ProcessDirectory($dirInfo, $subTablePtr);
             $pos = $strEnd + $valLen;
         } elsif ($string eq 'StringFileInfo' and $valLen == 0) {
@@ -762 +884 @@
                 $valLen = Get16u($dataPt, $pt + 2);
                 # $type = Get16u($dataPt, $pt + 4);
+                my $entryEnd = $pt + $len;
                 # get tag ID (converted to UTF8)
-                ($string, $pt) = ReadUnicodeStr($dataPt, $pt + 6);
+                ($string, $pt) = ReadUnicodeStr($dataPt, $pt + 6, $entryEnd);
                 unless ($index) {
                     # separate the language code and character set
@@ -774 +897 @@
                         $string = substr($string, 0, 4);
                     }
-                    $exifTool->HandleTag($tagTablePtr, 'LanguageCode', uc $string);
-                    $exifTool->HandleTag($tagTablePtr, 'CharacterSet', uc $char) if $char;
+                    $et->HandleTag($tagTablePtr, 'LanguageCode', uc $string);
+                    $et->HandleTag($tagTablePtr, 'CharacterSet', uc $char) if $char;
                     next;
                 }
@@ -784 +907 @@
                     $name =~ tr/-_a-zA-Z0-9//dc; # remove illegal characters
                     next unless length $name;
-                    Image::ExifTool::AddTagToTable($tagTablePtr, $tag, { Name => $name });
+                    AddTagToTable($tagTablePtr, $tag, { Name => $name });
                 }
                 # get tag value (converted to current Charset)
                 if ($valLen) {
-                    ($string, $pt) = ReadUnicodeStr($dataPt, $pt, $exifTool);
+                    ($string, $pt) = ReadUnicodeStr($dataPt, $pt, $entryEnd, $et);
                 } else {
                     $string = '';
                 }
-                $exifTool->HandleTag($tagTablePtr, $tag, $string);
+                $et->HandleTag($tagTablePtr, $tag, $string);
+                # step to next entry (padded to an even word)
+                $pt = ($entryEnd + 3) & 0xfffffffc;
             }
         } else {
@@ -808 +933 @@
 sub ProcessPEResources($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $base = $$dirInfo{Base};
     my $dirStart = $$dirInfo{DirStart} + $base;
     my $level = $$dirInfo{Level} || 0;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my ($buff, $buf2, $item);
 
@@ -833 +958 @@
             # ignore everything but the Version resource unless verbose
             if ($verbose) {
-                $exifTool->VPrint(0, "$resType resource:\n");
+                $et->VPrint(0, "$resType resource:\n");
             } else {
                 next unless $resType eq 'Version';
@@ -843 +968 @@
             $$dirInfo{DirStart} = $entryPos & 0x7fffffff;
             $$dirInfo{Level} = $level + 1;
-            ProcessPEResources($exifTool, $dirInfo) or return 0;
+            ProcessPEResources($et, $dirInfo) or return 0;
             --$$dirInfo{Level};
         } elsif ($$dirInfo{ResType} eq 'Version' and $level == 2 and
@@ -863 +988 @@
             return 0 unless $filePos;
             $raf->Seek($filePos, 0) and $raf->Read($buf2, $len) == $len or return 0;
-            ProcessPEVersion($exifTool, {
+            ProcessPEVersion($et, {
                 DataPt   => \$buf2,
                 DataLen  => $len,
                 DirStart => 0,
                 DirLen   => $len,
-            }) or $exifTool->Warn('Possibly corrupt Version resource');
+            }) or $et->Warn('Possibly corrupt Version resource');
             $$dirInfo{GotVersion} = 1;  # set flag so we don't do this again
         }
@@ -881 +1006 @@
 sub ProcessPEDict($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length($$dataPt);
-    my ($pos, @sections, %dirInfo);
+    my ($pos, @sections, %dirInfo, $rsrcFound);
 
     # loop through all sections
@@ -895 +1020 @@
         # remember the section offsets for the VirtualAddress lookup later
         push @sections, { Base => $offset, Size => $size, VirtualAddress => $va };
-        # save details of the first resource section
+        # save details of the first resource section (or .text if .rsrc not found, ref forum11465)
+        next unless ($name eq ".rsrc\0\0\0" and not $rsrcFound and defined($rsrcFound = 1)) or
+                    ($name eq ".text\0\0\0" and not %dirInfo);
         %dirInfo = (
             RAF      => $raf,
@@ -902 +1029 @@
             DirLen   => $size,
             Sections => \@sections,
-        ) if $name eq ".rsrc\0\0\0" and not %dirInfo;
+        );
     }
     # process the first resource section
-    ProcessPEResources($exifTool, \%dirInfo) or return 0 if %dirInfo;
+    ProcessPEResources($et, \%dirInfo) or return 0 if %dirInfo;
     return 1;
+}
+
+#------------------------------------------------------------------------------
+# Override file type if necessary for Mach object files and libraries
+# Inputs: 0) ExifTool ref, 1) ObjectFileType number, 2) flag for fat binary
+my %machOverride = (
+    1 => [ 'object file', 'O' ],
+    6 => [ 'dynamic link library', 'DYLIB' ],
+    8 => [ 'dynamic bound bundle', 'DYLIB' ],
+    9 => [ 'dynamic link library stub', 'DYLIB' ],
+);
+sub MachOverride($$;$)
+{
+    my ($et, $objType, $fat) = @_;
+    my $override = $machOverride{$objType};
+    if ($override) {
+        my $desc = 'Mach-O ' . ($fat ? 'fat ' : '') . $$override[0];
+        $et->OverrideFileType($desc, undef, $$override[1]);
+    }
+}
+
+#------------------------------------------------------------------------------
+# Extract tags from Mach header
+# Inputs: 0) ExifTool ref, 1) data ref, 2) flag to extract object type
+# Returns: true if Mach header was found
+# Mach type based on magic number
+# [bit depth, byte order starting with "Little" or "Big"]
+my %machType = (
+    "\xfe\xed\xfa\xce" => ['32 bit', 'Big endian'],
+    "\xce\xfa\xed\xfe" => ['32 bit', 'Little endian'],
+    "\xfe\xed\xfa\xcf" => ['64 bit', 'Big endian'],
+    "\xcf\xfa\xed\xfe" => ['64 bit', 'Little endian'],
+);
+sub ExtractMachTags($$;$)
+{
+    my ($et, $dataPt, $doObj) = @_;
+    # get information about mach header based on the magic number (first 4 bytes)
+    my $info = $machType{substr($$dataPt, 0, 4)};
+    if ($info) {
+        # Mach header structure:
+        #  0 int32u magic
+        #  4 int32u cputype
+        #  8 int32u cpusubtype
+        # 12 int32u filetype
+        # 16 int32u ncmds
+        # 20 int32u sizeofcmds
+        # 24 int32u flags
+        my $tagTablePtr = GetTagTable('Image::ExifTool::EXE::MachO');
+        SetByteOrder($$info[1]);
+        my $cpuType = Get32s($dataPt, 4);
+        my $subType = Get32s($dataPt, 8);
+        $et->HandleTag($tagTablePtr, 0, $$info[0]);
+        $et->HandleTag($tagTablePtr, 1, $$info[1]);
+        $et->HandleTag($tagTablePtr, 3, $cpuType);
+        $et->HandleTag($tagTablePtr, 4, "$cpuType $subType");
+        if ($doObj) {
+            my $objType = Get32u($dataPt, 12);
+            my $flags = Get32u($dataPt, 24);
+            $et->HandleTag($tagTablePtr, 5, $objType);
+            $et->HandleTag($tagTablePtr, 6, $flags);
+            # override file type if this is an object file or library
+            MachOverride($et, $objType);
+        } else { # otherwise this was a static library
+            $et->OverrideFileType('Mach-O static library', undef, 'A');
+        }
+        return 1;
+    }
+    return 0;
 }
 
@@ -915 +1110 @@
 sub ProcessEXE($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
-    my ($buff, $buf2, $type, $tagTablePtr, %dirInfo);
+    my ($buff, $buf2, $type, $mime, $ext, $tagTablePtr, %dirInfo);
 
     my $size = $raf->Read($buff, 0x40) or return 0;
+    my $fast3 = $$et{OPTIONS}{FastScan} && $$et{OPTIONS}{FastScan} == 3;
 #
 # DOS and Windows EXE
@@ -927 +1123 @@
         # validate DOS header
         # (ref http://www.delphidabbler.com/articles?article=8&part=2)
-        #   0  magic   : int16u    # Magic number ("MZ")
-        #   2  cblp    : int16u    # Bytes on last page of file
-        #   4  cp      : int16u    # Pages in file
-        #   6  crlc    : int16u    # Relocations
-        #   8  cparhdr : int16u    # Size of header in paragraphs
-        #  10  minalloc: int16u    # Minimum extra paragraphs needed
-        #  12  maxalloc: int16u    # Maximum extra paragraphs needed
-        #  14  ss      : int16u    # Initial (relative) SS value
-        #  16  sp      : int16u    # Initial SP value
-        #  18  csum    : int16u    # Checksum
-        #  20  ip      : int16u    # Initial IP value
-        #  22  cs      : int16u    # Initial (relative) CS value
-        #  24  lfarlc  : int16u    # Address of relocation table
-        #  26  ovno    : int16u    # Overlay number
-        #  28  res     : int16u[4] # Reserved words
-        #  36  oemid   : int16u    # OEM identifier (for oeminfo)
-        #  38  oeminfo : int16u    # OEM info; oemid specific
-        #  40  res2    : int16u[10]# Reserved words
-        #  60  lfanew  : int32u;   # File address of new exe header
+        #   0 int16u     magic    - Magic number ("MZ")
+        #   2 int16u     cblp     - Bytes on last page of file
+        #   4 int16u     cp       - Pages in file
+        #   6 int16u     crlc     - Relocations
+        #   8 int16u     cparhdr  - Size of header in paragraphs
+        #  10 int16u     minalloc - Minimum extra paragraphs needed
+        #  12 int16u     maxalloc - Maximum extra paragraphs needed
+        #  14 int16u     ss       - Initial (relative) SS value
+        #  16 int16u     sp       - Initial SP value
+        #  18 int16u     csum     - Checksum
+        #  20 int16u     ip       - Initial IP value
+        #  22 int16u     cs       - Initial (relative) CS value
+        #  24 int16u     lfarlc   - Address of relocation table
+        #  26 int16u     ovno     - Overlay number
+        #  28 int16u[4]  res      - Reserved words
+        #  36 int16u     oemid    - OEM identifier (for oeminfo)
+        #  38 int16u     oeminfo  - OEM info; oemid specific
+        #  40 int16u[10] res2     - Reserved words
+        #  60 int32u;    lfanew   - File address of new exe header
         SetByteOrder('II');
         my ($cblp, $cp, $lfarlc, $lfanew) = unpack('x2v2x18vx34V', $buff);
         my $fileSize = ($cp - ($cblp ? 1 : 0)) * 512 + $cblp;
-        return 0 if $fileSize < 0x40 or $fileSize < $lfarlc;
-        # read the Windows PE header
-        if ($lfarlc == 0x40 and $fileSize > $lfanew + 2 and
-            # read the Windows NE, PE or LE (virtual device driver) header
-            $raf->Seek($lfanew, 0) and $raf->Read($buff, 0x40) and
-            $buff =~ /^(NE|PE|LE)/)
-        {
+        #(patch to accommodate observed 64-bit files)
+        #return 0 if $fileSize < 0x40 or $fileSize < $lfarlc;
+        #return 0 if $fileSize < 0x40; (changed to warning in ExifTool 12.08)
+        $et->Warn('Invalid file size in DOS header') if $fileSize < 0x40;
+        # read the Windows NE, PE or LE (virtual device driver) header
+        #if ($lfarlc == 0x40 and $fileSize > $lfanew + 2 and ...
+        if ($raf->Seek($lfanew, 0) and $raf->Read($buff, 0x40) and $buff =~ /^(NE|PE|LE)/) {
             if ($1 eq 'NE') {
                 if ($size >= 0x40) { # NE header is 64 bytes (ref 2)
                     # check for DLL
                     my $appFlags = Get16u(\$buff, 0x0c);
-                    $type = 'Win16 ' . ($appFlags & 0x80 ? 'DLL' : 'EXE');
+                    $ext = $appFlags & 0x80 ? 'DLL' : 'EXE';
+                    $type = "Win16 $ext";
                     # offset 0x02 is 2 bytes with linker version and revision numbers
                     # offset 0x36 is executable type (2 = Windows)
@@ -974 +1171 @@
                 #  22 int16u Characteristics
                 if ($size >= 24) {  # PE header is 24 bytes (plus optional header)
-                    my $flags = Get16u(\$buff, 22);
-                    $exifTool->SetFileType('Win32 ' . ($flags & 0x2000 ? 'DLL' : 'EXE'));
+                    my $mach = Get16u(\$buff, 4);   # MachineType
+                    my $flags = Get16u(\$buff, 22); # ImageFileCharacteristics
+                    my $machine = $Image::ExifTool::EXE::Main{0}{PrintConv}{$mach} || '';
+                    my $winType = $machine =~ /64/ ? 'Win64' : 'Win32';
+                    $ext = $flags & 0x2000 ? 'DLL' : 'EXE';
+                    $et->SetFileType("$winType $ext", undef, $ext);
+                    return 1 if $fast3;
                     # read the rest of the optional header if necessary
                     my $optSize = Get16u(\$buff, 20);
@@ -984 +1186 @@
                             $size += $more;
                             my $magic = Get16u(\$buff, 24);
-                            # verify PE32/PE32+ magic number
-                            unless ($magic == 0x10b or $magic == 0x20b) {
-                                $exifTool->Warn('Unknown PE magic number');
+                            # verify PE magic number
+                            unless ($magic == 0x107 or $magic == 0x10b or $magic == 0x20b) {
+                                $et->Warn('Unknown PE magic number');
                                 return 1;
                             }
+                            # --> 64-bit if $magic is 0x20b ????
                         } else {
-                            $exifTool->Warn('Error reading optional header');
+                            $et->Warn('Error reading optional header');
                         }
                     }
@@ -1000 +1203 @@
                         DataLen => $size,
                         DirStart => 4,
-                        DirLen => $size,
+                        DirLen => $size - 4,
                     );
-                    $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
                     # process data dictionary
                     my $num = Get16u(\$buff, 6);    # NumberOfSections
@@ -1010 +1213 @@
                             DataPt => \$buff,
                         );
-                        ProcessPEDict($exifTool, \%dirInfo) or $exifTool->Warn('Error processing PE data dictionary');
+                        ProcessPEDict($et, \%dirInfo) or $et->Warn('Error processing PE data dictionary');
                     }
                     return 1;
@@ -1016 +1219 @@
             } else {
                 $type = 'Virtual Device Driver';
+                $ext = '386';
             }
         } else {
             $type = 'DOS EXE';
+            $ext = 'exe';
         }
 #
@@ -1029 +1234 @@
         if ($1 eq "\xca\xfe\xba\xbe") {
             SetByteOrder('MM');
-            $exifTool->SetFileType('Mach-O fat binary executable');
+            $et->SetFileType('Mach-O fat binary executable', undef, '');
+            return 1 if $fast3;
             my $count = Get32u(\$buff, 4);  # get architecture count
             my $more = $count * 20 - ($size - 8);
             if ($more > 0) {
                 unless ($raf->Read($buf2, $more) == $more) {
-                    $exifTool->Warn('Error reading fat-arch headers');
+                    $et->Warn('Error reading fat-arch headers');
                     return 1;
                 }
@@ -1040 +1246 @@
                 $size += $more;
             }
-            $exifTool->HandleTag($tagTablePtr, 2, $count);
+            $et->HandleTag($tagTablePtr, 2, $count);
             my $i;
             for ($i=0; $i<$count; ++$i) {
                 my $cpuType = Get32s(\$buff, 8 + $i * 20);
-                my $cpuSubtype = Get32u(\$buff, 12 + $i * 20);
-                $exifTool->HandleTag($tagTablePtr, 3, $cpuType);
-                $exifTool->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
+                my $subType = Get32s(\$buff, 12 + $i * 20);
+                $et->HandleTag($tagTablePtr, 3, $cpuType);
+                $et->HandleTag($tagTablePtr, 4, "$cpuType $subType");
             }
             # load first Mach-O header to get the object file type
@@ -1053 +1259 @@
                 if ($buf2 =~ /^(\xfe\xed\xfa(\xce|\xcf)|(\xce|\xcf)\xfa\xed\xfe)/) {
                     SetByteOrder($buf2 =~ /^\xfe\xed/ ? 'MM' : 'II');
-                    my $objType = Get32s(\$buf2, 12);
-                    $exifTool->HandleTag($tagTablePtr, 5, $objType);
+                    my $objType = Get32u(\$buf2, 12);
+                    $et->HandleTag($tagTablePtr, 5, $objType);
+                    # override file type if this is a library or object file
+                    MachOverride($et, $objType, 'fat');
                 } elsif ($buf2 =~ /^!<arch>\x0a/) {
                     # .a libraries use this magic number
-                    $exifTool->HandleTag($tagTablePtr, 5, -1);
+                    $et->HandleTag($tagTablePtr, 5, -1);
+                    # override file type since this is a library
+                    $et->OverrideFileType('Mach-O fat static library', undef, 'A');
                 } else {
-                    $exifTool->Warn('Unrecognized object file type');
+                    $et->Warn('Unrecognized object file type');
                 }
             } else {
-                $exifTool->Warn('Error reading file');
+                $et->Warn('Error reading file');
             }
-       } elsif ($size >= 16) {
-            $exifTool->SetFileType('Mach-O executable');
-            my $info = {
-                "\xfe\xed\xfa\xce" => ['32 bit', 'Big endian'],
-                "\xce\xfa\xed\xfe" => ['32 bit', 'Little endian'],
-                "\xfe\xed\xfa\xcf" => ['64 bit', 'Big endian'],
-                "\xcf\xfa\xed\xfe" => ['64 bit', 'Little endian'],
-            }->{substr($buff, 0, 4)};
-            my $byteOrder = ($buff =~ /^\xfe/) ? 'MM' : 'II';
-            SetByteOrder($byteOrder);
-            my $cpuType = Get32s(\$buff, 4);
-            my $cpuSubtype = Get32s(\$buff, 8);
-            my $objType = Get32s(\$buff, 12);
-            $exifTool->HandleTag($tagTablePtr, 0, $$info[0]);
-            $exifTool->HandleTag($tagTablePtr, 1, $$info[1]);
-            $exifTool->HandleTag($tagTablePtr, 3, $cpuType);
-            $exifTool->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
-            $exifTool->HandleTag($tagTablePtr, 5, $objType);
+        } elsif ($size >= 16) {
+            $et->SetFileType('Mach-O executable', undef, '');
+            return 1 if $fast3;
+            ExtractMachTags($et, \$buff, 1);
         }
         return 1;
@@ -1089 +1285 @@
     } elsif ($buff =~ /^Joy!peff/ and $size > 12) {
         # ref http://developer.apple.com/documentation/mac/pdf/MacOS_RT_Architectures.pdf
-        $exifTool->SetFileType('Classic MacOS executable');
+        $et->SetFileType('Classic MacOS executable', undef, '');
+        return 1 if $fast3;
         SetByteOrder('MM');
         $tagTablePtr = GetTagTable('Image::ExifTool::EXE::PEF');
@@ -1099 +1296 @@
             DirLen => $size,
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         return 1;
 #
@@ -1105 +1302 @@
 #
     } elsif ($buff =~ /^\x7fELF/ and $size >= 16) {
-        $exifTool->SetFileType("ELF executable");
+        $et->SetFileType('ELF executable', undef, '');
+        return 1 if $fast3;
         SetByteOrder(Get8u(\$buff,5) == 1 ? 'II' : 'MM');
         $tagTablePtr = GetTagTable('Image::ExifTool::EXE::ELF');
         %dirInfo = (
-            DataPt => \$buff,
+            DataPt  => \$buff,
             DataPos => 0,
             DataLen => $size,
-            DirStart => 0,
-            DirLen => $size,
+            DirLen  => $size,
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        # override file type if this is a library or object file
+        my $override = {
+            1 => [ 'ELF object file', 'O' ],
+            3 => [ 'ELF shared library', 'SO' ],
+        }->{$$et{VALUE}{ObjectFileType} || 0};
+        $et->OverrideFileType($$override[0], undef, $$override[1]) if $override;
+        return 1;
+#
+# .a libraries
+#
+    } elsif ($buff =~ /^!<arch>\x0a/) {
+        $et->SetFileType('Static library', undef, 'A');
+        return 1 if $fast3;
+        my $pos = 8;    # current file position
+        my $max = 10;   # maximum number of archive files to check
+        # read into list of ar structures (each 60 bytes long):
+        while ($max-- > 0) {
+            # seek to start of the ar structure and read it
+            $raf->Seek($pos, 0) and $raf->Read($buff, 60) == 60 or last;
+            substr($buff, 58, 2) eq "`\n" or $et->Warn('Invalid archive header'), last;
+            unless ($tagTablePtr) {
+                # extract some information from first file in archive
+                $tagTablePtr = GetTagTable('Image::ExifTool::EXE::AR');
+                %dirInfo = (
+                    DataPt  => \$buff,
+                    DataPos => $pos,
+                );
+                $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            }
+            my $name = substr($buff, 0, 16);
+            if ($name =~ m{^#1/(\d+) *$}) { # check for extended archive (BSD variant)
+                my $len = $1;
+                $len > 256 and $et->Warn('Invalid extended archive name length'), last;
+                # (we read the name here just to move the file pointer)
+                $raf->Read($name, $len) == $len or $et->Warn('Error reading archive name'), last;
+            }
+            my $arSize = substr($buff, 48, 10);
+            $arSize =~ s/^(\d+).*/$1/s or last;     # make sure archive size is a number
+            $raf->Read($buff, 28) == 28 or last;    # read (possible) Mach header
+            ExtractMachTags($et, \$buff) and last;  # try to extract tags
+            $pos += 60 + $arSize;   # step to next entry
+            ++$pos if $pos & 0x01;  # padded to an even byte
+        }
         return 1;
 #
@@ -1121 +1361 @@
 #
     } elsif ($buff =~ m{^#!\s*/\S*bin/(\w+)}) {
-        $type = "$1 script";
-#
-# .a libraries
-#
-    } elsif ($buff =~ /^!<arch>\x0a/) {
-        $type = 'Static library',
+        my $prog = $1;
+        $prog = $1 if $prog eq 'env' and $buff =~ /\b(perl|python|ruby|php)\b/;
+        $type = "$prog script";
+        $mime = "text/x-$prog";
+        $ext = {
+            perl   => 'pl',
+            python => 'py',
+            ruby   => 'rb',
+            php    => 'php',
+        }->{$prog};
+        # use '.sh' for extension of all shell scripts
+        $ext = $prog =~ /sh$/ ? 'sh' : '' unless defined $ext;
     }
     return 0 unless $type;
-    $exifTool->SetFileType($type);
+    $et->SetFileType($type, $mime, $ext);
     return 1;
 }
@@ -1153 +1399 @@
 =head1 AUTHOR
 
-Copyright 2003-2011, Phil Harvey (phil at owl.phy.queensu.ca)
+Copyright 2003-2021, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it