utf8_heavy: Return values for binary property requested as map

Future commits will make Unicode::UCD return maps of all properties.
Instead of storing these maps on disk, they can be inferred from the
files that are already there that give the code points that match the
property.

This commit causes a request for the mapping of such a property to
instead return the data from the binary definition file.

It is left for the caller to convert this data into a map.  These files
do not have SwashInfo defined; and the returned BITS field in the swash
will be 1.

1 files changed, 44 insertions, 3 deletions

diff --git a/lib/utf8_heavy.pl b/lib/utf8_heavy.pl
index 5313902642..6df7d35163 100644
--- a/lib/utf8_heavy.pl
+++ b/lib/utf8_heavy.pl
@@ -424,8 +424,8 @@ sub _loose_name ($) {
                 ## is to use Unicode::UCD.
                 ##
                 # Only check if caller wants non-binary
-                if ($minbits != 1 && $property_and_table =~ s/^to//) {
-
+                my $retried = 0;
+                if ($minbits != 1 && $property_and_table =~ s/^to//) {{
                     # Look input up in list of properties for which we have
                     # mapping files.
                     if (defined ($file =
@@ -435,8 +435,49 @@ sub _loose_name ($) {
                         print STDERR __LINE__, ": type set to $type\n" if DEBUG;
                         $file = "$unicore_dir/$file.pl";
                         last GETFILE;
+                    }   # If that fails see if there is a corresponding binary
+                        # property file
+                    elsif (defined ($file =
+                                   $utf8::loose_to_file_of{$property_and_table}))
+                    {
+
+                        # Here, there is no map file for the property we are
+                        # trying to get the map of, but this is a binary
+                        # property, and there is a file for it that can easily
+                        # be translated to a mapping.
+
+                        # In the case of properties that are forced to binary,
+                        # they are a combination.  We return the actual
+                        # mapping instead of the binary.  If the input is
+                        # something like 'Tocjkkiicore', it will be found in
+                        # %loose_property_to_file_of above as => 'To/kIICore'.
+                        # But the form like ToIskiicore won't be.  To fix
+                        # this, it was easiest to do it here.  These
+                        # properties are the complements of the default
+                        # property, so there is an entry in %loose_to_file_of
+                        # that is 'iskiicore' => '!kIICore/N', If we find such
+                        # an entry, strip off things and try again, which
+                        # should find the entry in %loose_property_to_file_of.
+                        # Actual binary properties that are of this form, such
+                        # as this entry: 'ishrkt' => '!Perl/Any' will also be
+                        # retried, but won't be in %loose_property_to_file_of,
+                        # and instead the next time through, it will find
+                        # 'hrkt' => '!Perl/Any' and proceed.
+                        redo if ! $retried
+                                && $file =~ /^!/
+                                && $property_and_table =~ s/^is//;
+
+                        # This is a binary property.  Setting this here causes
+                        # it to be stored as such in the cache, so if someone
+                        # comes along later looking for just a binary, they
+                        # get it.
+                        $minbits = 1;
+
+                        $invert_it = $file =~ s/^!//;
+                        $file = "$unicore_dir/lib/$file.pl";
+                        last GETFILE;
                     }
-                }
+                } }
 
                 ##
                 ## If we reach this line, it's because we couldn't figure