exiftool-vendored.exe 12.80.0 → 12.82.1

package/bin/exiftool_files/lib/Unicode/LineBreak.pm

@@ -0,0 +1,248 @@
+#-*- perl -*-
+
+package Unicode::LineBreak;
+require 5.008;
+
+### Pragmas:
+use strict;
+use warnings;
+use vars qw($VERSION @EXPORT_OK @ISA $Config @Config);
+
+### Exporting:
+use Exporter;
+our @EXPORT_OK = qw(UNICODE_VERSION SOMBOK_VERSION context);
+our %EXPORT_TAGS = ('all' => [@EXPORT_OK]);
+
+### Inheritance:
+our @ISA = qw(Exporter);
+
+### Other modules:
+use Carp qw(croak carp);
+use Encode qw(is_utf8);
+use MIME::Charset;
+use Unicode::GCString;
+
+### Globals
+
+### The package version
+our $VERSION = '2019.001';
+
+### Public Configuration Attributes
+our @Config = (
+    BreakIndent => 'YES',
+    CharMax => 998,
+    ColMax => 76,
+    ColMin => 0,
+    ComplexBreaking => 'YES',
+    Context => 'NONEASTASIAN',
+    EAWidth => undef,
+    Format => 'SIMPLE',
+    HangulAsAL => 'NO',
+    LBClass => undef,
+    LegacyCM => 'YES',
+    Newline => "\n",
+    Prep => undef,
+    Sizing => 'UAX11',
+    Urgent => undef,
+    ViramaAsJoiner => 'YES',
+);
+our $Config = {};
+eval { require Unicode::LineBreak::Defaults; };
+push @Config, (%$Config);
+
+### Exportable constants
+use Unicode::LineBreak::Constants;
+use constant 1.01;
+my $package = __PACKAGE__;
+my @consts = grep { s/^${package}::(\w\w+)$/$1/ } keys %constant::declared;
+push @EXPORT_OK, @consts;
+push @{$EXPORT_TAGS{'all'}}, @consts;
+
+### Load XS module
+require XSLoader;
+XSLoader::load('Unicode::LineBreak', $VERSION);
+
+### Load dynamic constants
+foreach my $p ((['EA', EAWidths()], ['LB', LBClasses()])) {
+    my $prop = shift @{$p};
+    my $idx = 0;
+    foreach my $val (@{$p}) {
+        no strict;
+        my $const = "${prop}_${val}";
+        *{$const} = eval "sub { $idx }";
+        push @EXPORT_OK, $const;
+        push @{$EXPORT_TAGS{'all'}}, $const;
+        $idx++;
+    }
+}
+
+### Privates
+my $EASTASIAN_CHARSETS = qr{
+    ^BIG5 |
+    ^CP9\d\d |
+    ^EUC- |
+    ^GB18030 | ^GB2312 | ^GBK |
+    ^HZ |
+    ^ISO-2022- |
+    ^KS_C_5601 |
+    ^SHIFT_JIS
+}ix;
+
+my $EASTASIAN_LANGUAGES = qr{
+    ^AIN |
+    ^JA\b | ^JPN |
+    ^KO\b | ^KOR |
+    ^ZH\b | ^CHI
+}ix;
+
+use overload
+    '%{}' => \&as_hashref,
+    '${}' => \&as_scalarref,
+    '""' => \&as_string,
+    ;
+
+sub new {
+    my $class = shift;
+
+    my $self = __PACKAGE__->_new();
+    $self->config(@Config);
+    $self->config(@_);
+    bless $self, $class;
+}
+
+sub config ($@) {
+    my $self = shift;
+
+    # Get config.
+    if (scalar @_ == 1) {
+        my $k = shift;
+        my $ret;
+
+        if (uc $k eq uc 'CharactersMax') {
+            return $self->_config('CharMax');
+        } elsif (uc $k eq uc 'ColumnsMax') {
+            return $self->_config('ColMax');
+        } elsif (uc $k eq uc 'ColumnsMin') {
+            return $self->_config('ColMin');
+        } elsif (uc $k eq uc 'SizingMethod') {
+            return $self->_config('Sizing');
+        } elsif (uc $k eq uc 'TailorEA') {
+            carp "$k is obsoleted.  Use EAWidth";
+            $ret = $self->_config('EAWidth');
+            if (! defined $ret) {
+                return [];
+            } else {
+                return [map { ($_->[0] => $_->[1]) } @{$ret}];
+            }
+        } elsif (uc $k eq uc 'TailorLB') {
+            carp "$k is obsoleted.  Use LBClass";
+            $ret = $self->_config('LBClass');
+            if (! defined $ret) {
+                return [];
+            } else {
+                return [map { ($_->[0] => $_->[1]) } @{$ret}];
+            }
+        } elsif (uc $k eq uc 'UrgentBreaking') {
+            return $self->_config('Urgent');
+        } elsif (uc $k eq uc 'UserBreaking') {
+            carp "$k is obsoleted.  Use Prep";
+            $ret = $self->_config('Prep');
+            if (! defined $ret) {
+                return [];
+            } else {
+                return $ret;
+            }
+        } else {
+            return $self->_config($k);
+        }
+    }
+
+    # Set config.
+    my @config = ();
+    while (0 < scalar @_) {
+        my $k = shift;
+        my $v = shift;
+
+        if (uc $k eq uc 'CharactersMax') {
+            push @config, 'CharMax' => $v;
+        } elsif (uc $k eq uc 'ColumnsMax') {
+            push @config, 'ColMax' => $v;
+        } elsif (uc $k eq uc 'ColumnsMin') {
+            push @config, 'ColMin' => $v;
+        } elsif (uc $k eq uc 'SizingMethod') {
+            push @config, 'Sizing' => $v;
+        } elsif (uc $k eq uc 'TailorLB') {
+            carp "$k is obsoleted.  Use LBClass";
+            push @config, 'LBClass' => undef;
+            if (! defined $v) {
+                ;
+            } else {
+                my @v = @{$v};
+                while (scalar(@v)) {
+                    my $k = shift @v;
+                    my $v = shift @v;
+                    push @config, 'LBClass' => [ $k => $v ];
+                }
+            }
+        } elsif (uc $k eq uc 'TailorEA') {
+            carp "$k is obsoleted.  Use EAWidth";
+            push @config, 'EAWidth' => undef;
+            if (! defined $v) {
+                ;
+            } else {
+                my @v = @{$v};
+                while (scalar(@v)) {
+                    my $k = shift @v;
+                    my $v = shift @v;
+                    push @config, 'EAWidth' => [ $k => $v ];
+                }
+            }
+        } elsif (uc $k eq uc 'UserBreaking') {
+            carp "$k is obsoleted.  Use Prep";
+            push @config, 'Prep' => undef;
+            if (! defined $v) {
+                ;
+            } elsif (ref $v eq 'ARRAY') {
+                push @config, map { ('Prep' => $_) } @{$v};
+            } else {
+                push @config, 'Prep' => $v;
+            }
+        } elsif (uc $k eq uc 'UrgentBreaking') {
+            push @config, 'Urgent' => $v;
+        } else {
+            push @config, $k => $v;
+        }
+    }
+
+    $self->_config(@config) if scalar @config;
+}
+
+sub context (@) {
+    my %opts = @_;
+
+    my $charset;
+    my $language;
+    my $context;
+    foreach my $k (keys %opts) {
+        if (uc $k eq 'CHARSET') {
+            if (ref $opts{$k}) {
+                $charset = $opts{$k}->as_string;
+            } else {
+                $charset = MIME::Charset->new($opts{$k})->as_string;
+            }
+        } elsif (uc $k eq 'LANGUAGE') {
+            $language = uc $opts{$k};
+            $language =~ s/_/-/;
+        }
+    }
+    if ($charset and $charset =~ /$EASTASIAN_CHARSETS/) {
+        $context = 'EASTASIAN';
+    } elsif ($language and $language =~ /$EASTASIAN_LANGUAGES/) {
+        $context = 'EASTASIAN';
+    } else {
+        $context = 'NONEASTASIAN';
+    }
+    $context;
+}
+
+1;

package/bin/exiftool_files/lib/Win32/API/Struct.pm

@@ -576,180 +576,4 @@ __END__
 # DOCUMENTATION
 #
 
-=head1 NAME
-
-Win32::API::Struct - C struct support package for Win32::API
-
-=head1 SYNOPSIS
-
-  use Win32::API;
-  
-  Win32::API::Struct->typedef( 'POINT', qw(
-    LONG x; 
-    LONG y; 
-  ));
-  
-  my $Point = Win32::API::Struct->new( 'POINT' ); 
-  $Point->{x} = 1024;
-  $Point->{y} = 768;
-
-  #### alternatively
-  
-  tie %Point, 'Win32::API::Struct', 'POINT';
-  $Point{x} = 1024;
-  $Point{y} = 768;
-
-
-=head1 ABSTRACT
-
-This module enables you to define C structs for use with
-Win32::API. 
-
-See L<Win32::API/USING STRUCTURES> for more info about its usage.
-
-=head1 DESCRIPTION
-
-This module is automatically imported by Win32::API, so you don't 
-need to 'use' it explicitly. The main methods are C<typedef> and
-C<new>, which are documented below.
-
-=over 4
-
-=item C<typedef NAME, TYPE, MEMBER, TYPE, MEMBER, ...>
-
-This method defines a structure named C<NAME>. The definition consists
-of types and member names, just like in C. In fact, most of the
-times you can cut the C definition for a structure and paste it
-verbatim to your script, enclosing it in a C<qw()> block. The 
-function takes care of removing the semicolon after the member
-name. Win32::API::Struct does B<NOT> support Enums, Unions, or Bitfields.
-C<NAME> must not end in C<*>, typedef creates structs, not struct pointers.
-See L<Win32::API::Type/"typedef">
-on how to create a struct pointer type. Returns true on success, and undef on error.
-On error it L<warns|perlfunc/warn> with the specific reason.
-
-The synopsis example could be written like this:
-
-  Win32::API::Struct->typedef('POINT', 'LONG', 'x', 'LONG', 'y');
-
-But it could also be written like this (note the indirect object
-syntax), which is pretty cool:
-
-  typedef Win32::API::Struct POINT => qw{
-    LONG x; 
-    LONG y; 
-  };
-
-L<Win32::API/Call> automatically knows that an 'LPNAME' type, refers
-to a 'NAME' type struct. Also see L<Win32::API::Type/"typedef"> on how to declare
-pointers to struct types.
-
-Unlike in Win32::API, a single non-array char or CHAR struct member in a
-struct is numeric, NOT the first character of a string. UTF16 strings pointers
-will be garbage on read back (passing in works, returning doesn't) since
-the NULL character will often be the 2nd byte of the UTF16 string.
-
-=item C<new NAME>
-
-This creates a structure (a Win32::API::Struct object) of the
-type C<NAME> (it must have been defined with C<typedef>). In Perl,
-when you create a structure, all the members are undefined. But
-when you use that structure in C (eg. a Win32::API call), you
-can safely assume that they will be treated as zero (or NULL).
-
-=item C<sizeof>
-
-This returns the size, in bytes, of the structure. Acts just like
-the C function of the same name. It is particularly useful for 
-structures that need a member to be initialized to the structure's
-own size.
-
-=item C<align [SIZE]>
-
-Sets or returns the structure alignment (eg. how the structure is
-stored in memory). This is a very advanced option, and you normally 
-don't need to mess with it. 
-All structures in the Win32 Platform SDK should work without it. 
-But if you define your own structure, you may need to give it an 
-explicit alignment. In most cases, passing a C<SIZE> of 'auto' 
-should keep the world happy.
-
-=back
-
-=head2 THE C<tie> INTERFACE
-
-Instead of creating an object with the C<new> method, you can
-tie a hash, which will hold the desired structure, using the 
-C<tie> builtin function:
-
-  tie %structure, Win32::API::Struct => 'NAME';
-
-The differences between the tied and non-tied approaches are:
-
-=over 4
-
-=item *
-with tied structures, you can access members directly as
-hash lookups, eg.
-
-  # tied              # non-tied
-  $Point{x}    vs.    $Point->{x}
-
-=item *
-with tied structures, when you try to fetch or store a
-member that is not part of the structure, it will result
-in a warning, eg.
-
-  print $Point{z};
-  # this will warn: 'z' is not a member of Win32::API::Struct POINT
-
-=item *
-when you pass a tied structure as a Win32::API parameter, 
-remember to backslash it, eg.
-
-  # tied                            # non-tied
-  GetCursorPos( \%Point )    vs.    GetCursorPos( $Point )
-
-=back
-
-=head2 FOREIGN MEMORY ALLOCATORS
-
-Using Win32::API::Struct is not recommended in situations where a C function
-will return results to you by putting a pointer to a string or a pointer to
-another struct into your supplied struct. Win32::API::Struct will do its best
-to detect that a new pointer appeared and to read it contents into Perl, but
-that pointer will be tossed away after being read. If this pointer is
-something you must explicitly free, you have leaked it by using
-Win32::API::Struct to decode it. If this pointer is something you must pass back to
-the C API you are using, you lost/leaked it. If you pass NULL, or a ::Struct
-pointer in a ::Struct to C API, after the C API call, ::Struct will detect the
-pointer changed, it will read the new struct from the new pointer into
-Perl, and a new child ::Struct will appear in the hash slice
-of the parent ::Struct, if you pass this new child ::Struct into the C API
-it will be a B<COPY> of the struct the C API from Perl's allocation placed
-in the parent ::Struct. For C++-like APIs, this will be unacceptable and lead to
-crashes as the C Functions tries to free a memory block that didn't come from the
-allocator of the C Function. Windows has many memory allocators, each CRT
-(VS 2, 3, 4, 5, NT/6, 7.0, 7.1, 8, 9, 10) malloc, LocalAlloc, GlobalAlloc,
-HeapAlloc, (each version of C++ Runtime Library) "new", CoGetMalloc, CoTaskMemAlloc,
-NetApiBufferAllocate, VirtualAlloc, CryptMemAlloc, AllocADsMem, SHAlloc,
-SnmpUtilMemAlloc. None of these allocators' pointers are compatible with Perl's
-allocator. Some C APIs give you static global buffers which never are freed or freed
-automatically in the next call to a function from to that DLL.
-
-With foreign allocators, its best to treat to write a pointer class, bless the
-ref to scalar integer (holding the pointer) into that class to ensure that the
-DESTROY method will free the pointer and you never leak it, and your write
-method accessors using L<perlfunc/pack>, L<Win32::API/ReadMemory> and
-L<Win32::API/WriteMemory> around the pointer.
-
-
-=head1 AUTHOR
-
-Aldo Calpini ( I<dada@perl.it> ).
-
-=head1 MAINTAINER
-
-Cosimo Streppone ( I<cosimo@cpan.org> ).
-
-=cut
+#line 756

package/bin/exiftool_files/lib/Win32/API/Type.pm

@@ -309,106 +309,7 @@ sub Unpack {
 # DOCUMENTATION
 #
 
-=head1 NAME
-
-Win32::API::Type - C type support package for Win32::API
-
-=head1 SYNOPSIS
-
-  use Win32::API;
-  
-  Win32::API::Type->typedef( 'my_number', 'LONG' );
-
-
-=head1 ABSTRACT
-
-This module is a support package for Win32::API that implements
-C types for the import with prototype functionality.
-
-See L<Win32::API> for more info about its usage.
-
-=head1 DESCRIPTION
-
-This module is automatically imported by Win32::API, so you don't 
-need to 'use' it explicitly. These are the methods of this package:
-
-=over 4
-
-=item C<typedef NAME, TYPE>
-
-This method defines a new type named C<NAME>. This actually just 
-creates an alias for the already-defined type C<TYPE>, which you
-can use as a parameter in a Win32::API call.
-
-When C<TYPE> contains a Win32::API::Struct type declared with
-L<Win32::API::Struct/typedef> with " *" postfixed to C<TYPE> parameter,
-C<NAME> will be a alias for the pointer version of the struct type. Creating
-an alias for a struct type is not supported, you have to call
-L<Win32::API::Struct/typedef> again. Passing a struct type as C<TYPE>
-without the " *" postfix is not supported.
-
-L<Warns|perlfunc/warn> and returns undef if C<TYPE> is unknown, else returns true.
-
-=item C<sizeof TYPE>
-
-This returns the size, in bytes, of C<TYPE>. Acts just like
-the C function of the same name. 
-
-=item C<is_known TYPE>
-
-Returns true if C<TYPE> is known by Win32::API::Type, false
-otherwise.
-
-=back
-
-=head2 SUPPORTED TYPES
-
-This module recognizes many commonly used types defined in the Win32 Platform
-SDK header files, but not all. Types less than 13 years old are very unlikely
-to be the in built type database.
-
-Please see the source for this module, in the C<__DATA__> section,
-for the full list of builtin supported types.
-
-
-=head2 NOTES ON SELECT TYPES
-
-=over 4
-
-=item LPVOID
-
-Due to poor design, currently LPVOID is a char *, a string, not a number.
-It should really be a number. It is suggested to replace LPVOID in your
-C prototypes passed to Win32::API with UINT_PTR which is a pointer
-sized number.
-
-=item SOMETYPE **
-
-Currently ** types do not parse.
-
-=item void **
-
-Replace void ** in your C prototype that you pass to Win32::API::More with
-LPHANDLE.
-
-=item unsigned char
-
-=item signed char
-
-These 2 types by name force numeric handling. C<97> not C<"a">. C<UCHAR> is
-not a C<unsigned char> for numeric handling purposes.
-
-=back
-
-=head1 AUTHOR
-
-Aldo Calpini ( I<dada@perl.it> ).
-
-=head1 MAINTAINER
-
-Cosimo Streppone ( I<cosimo@cpan.org> ).
-
-=cut
+#line 412
 
 
 __DATA__