package utf8;
use strict;
use warnings;
+use re "/aa"; # So we won't even try to look at above Latin1, potentially
+ # resulting in a recursive call
sub DEBUG () { 0 }
$|=1 if DEBUG;
sub croak { require Carp; Carp::croak(@_) }
+# Digits may be separated by a single underscore
+my $digits = qr/ ( [0-9] _? )+ (?!:_) /x;
+
+# A sign can be surrounded by white space
+my $sign = qr/ \s* [+-]? \s* /x;
+
+my $f_float = qr/ $sign $digits+ \. $digits* # e.g., 5.0, 5.
+ | $sign $digits* \. $digits+/x; # 0.7, .7
+
+# A number may be an integer, a rational, or a float with an optional exponent
+# We (shudder) accept a signed denominator
+my $number = qr{ ^ $sign $digits+ $
+ | ^ $sign $digits+ \/ $sign $digits+ $
+ | ^ $f_float (?: [Ee] [+-]? $digits )? $}x;
+
sub _loose_name ($) {
# Given a lowercase property or property-value name, return its
# standardized version that is expected for look-up in the 'loose' hashes
# out blanks, underscores and dashes. The complication stems from the
# grandfathered-in 'L_', which retains a single trailing underscore.
- my $loose = $_[0] =~ s/[-\s_]//rg;
+# integer or float (no exponent)
+my $integer_or_float_re = qr/ ^ -? \d+ (:? \. \d+ )? $ /x;
+
+# Also includes rationals
+my $numeric_re = qr! $integer_or_float_re | ^ -? \d+ / \d+ $ !x;
+ return $_[0] if $_[0] =~ $numeric_re;
+
+ (my $loose = $_[0]) =~ s/[-_ \t]//g;
return $loose if $loose !~ / ^ (?: is | to )? l $/x;
return 'l_' if $_[0] =~ / l .* _ /x; # If original had a trailing '_'
##
## Callers of swash_init:
## op.c:pmtrans -- for tr/// and y///
- ## regexec.c:regclass_swash -- for /[]/, \p, and \P
- ## utf8.c:is_utf8_common -- for common Unicode properties
- ## utf8.c:to_utf8_case -- for lc, uc, ucfirst, etc. and //i
## Unicode::UCD::prop_invlist
## Unicode::UCD::prop_invmap
##
# keys TYPE, BITS, EXTRAS, LIST, and NONE with values having the
# same meanings as the input parameters.
# SPECIALS contains a reference to any special-treatment hash in the
+ # property.
# INVERT_IT is non-zero if the result should be inverted before use
# USER_DEFINED is non-zero if the result came from a user-defined
- # property.
my $file; ## file to load data from, and also part of the %Cache key.
# Change this to get a different set of Unicode tables
my $caller0 = caller(0);
- my $caller1 = $type =~ s/(.+)::// ? $1 : $caller0 eq 'main' ?
- 'main' : caller(1);
+ my $caller1 = $type =~ s/(.+):://
+ ? $1
+ : $caller0 eq 'main'
+ ? 'main'
+ : caller(1);
if (defined $caller1 && $type =~ /^I[ns]\w+$/) {
my $prop = "${caller1}::$type";
}
if (miniperl) {
eval "require '$unicore_dir/Heavy.pl'";
- last GETFILE if $@;
+ if ($@) {
+ print STDERR __LINE__, ": '$@'\n" if DEBUG;
+ pop @recursed if @recursed;
+ return $type;
+ }
}
else {
require "$unicore_dir/Heavy.pl";
# If the rhs looks like it is a number...
print STDERR __LINE__, ": table=$table\n" if DEBUG;
- if ($table =~ qr{ ^ [ \s 0-9 _ + / . -]+ $ }x) {
- print STDERR __LINE__, ": table=$table\n" if DEBUG;
- # Don't allow leading nor trailing slashes
- if ($table =~ / ^ \/ | \/ $ /x) {
- pop @recursed if @recursed;
- return $type;
- }
+ if ($table =~ $number) {
+ print STDERR __LINE__, ": table=$table\n" if DEBUG;
# Split on slash, in case it is a rational, like \p{1/5}
- my @parts = split qr{ \s* / \s* }x, $table, -1;
+ my @parts = split m{ \s* / \s* }x, $table, -1;
print __LINE__, ": $type\n" if @parts > 2 && DEBUG;
- # Can have maximum of one slash
- if (@parts > 2) {
- pop @recursed if @recursed;
- return $type;
- }
-
foreach my $part (@parts) {
print __LINE__, ": part=$part\n" if DEBUG;
# minus
# Remove underscores between digits.
- $part =~ s/( ?<= [0-9] ) _ (?= [0-9] ) //xg;
+ $part =~ s/(?<= [0-9] ) _ (?= [0-9] ) //xg;
# No leading zeros (but don't make a single '0'
# into a null string)
$part .= '0' if $part eq '-' || $part eq "";
# No trailing zeros after a decimal point
- $part =~ s/ ( \. .*? ) 0+ $ /$1/x;
+ $part =~ s/ ( \. [0-9]*? ) 0+ $ /$1/x;
# Begin with a 0 if a leading decimal point
$part =~ s/ ^ ( -? ) \. /${1}0./x;
print STDERR __LINE__, ": part=$part\n" if DEBUG;
#return $type if $part eq "";
-
- # Result better look like a number. (This test is
- # needed because, for example could have a plus in
- # the middle.)
- if ($part !~ / ^ -? [0-9]+ ( \. [0-9]+)? $ /x) {
- pop @recursed if @recursed;
- return $type;
- }
}
# If a rational...
if ($parts[1] =~ s/^-//) {
# If numerator is also negative, convert the
- # whole thing to positive, or move the minus to
- # the numerator
+ # whole thing to positive, else move the minus
+ # to the numerator
if ($parts[0] !~ s/^-//) {
$parts[0] = '-' . $parts[0];
}
$table = $parts[0];
} else {
- # Here is a floating point numeric_value. Try to
- # convert to rational. First see if is in the list
- # of known ones.
- if (exists $utf8::nv_floating_to_rational{$parts[0]}) {
- $table = $utf8::nv_floating_to_rational{$parts[0]};
- } else {
-
- # Here not in the list. See if is close
- # enough to something in the list. First
- # determine what 'close enough' means. It has
- # to be as tight as what mktables says is the
- # maximum slop, and as tight as how many
- # digits we were passed. That is, if the user
- # said .667, .6667, .66667, etc. we match as
- # many digits as they passed until get to
- # where it doesn't matter any more due to the
- # machine's precision. If they said .6666668,
- # we fail.
- (my $fraction = $parts[0]) =~ s/^.*\.//;
- my $epsilon = 10 ** - (length($fraction));
- if ($epsilon > $utf8::max_floating_slop) {
- $epsilon = $utf8::max_floating_slop;
- }
+ # Here is a floating point numeric_value. Convert
+ # to rational. Get a normalized form, like
+ # 5.00E-01, and look that up in the hash
- # But it can't be tighter than the minimum
- # precision for this machine. If haven't
- # already calculated that minimum, do so now.
- if (! defined $min_floating_slop) {
-
- # Keep going down an order of magnitude
- # until find that adding this quantity to
- # 1 remains 1; but put an upper limit on
- # this so in case this algorithm doesn't
- # work properly on some platform, that we
- # won't loop forever.
- my $count = 0;
- $min_floating_slop = 1;
- while (1+ $min_floating_slop != 1
- && $count++ < 50)
- {
- my $next = $min_floating_slop / 10;
- last if $next == 0; # If underflows,
- # use previous one
- $min_floating_slop = $next;
- print STDERR __LINE__, ": min_float_slop=$min_floating_slop\n" if DEBUG;
- }
-
- # Back off a couple orders of magnitude,
- # just to be safe.
- $min_floating_slop *= 100;
- }
-
- if ($epsilon < $min_floating_slop) {
- $epsilon = $min_floating_slop;
- }
- print STDERR __LINE__, ": fraction=.$fraction; epsilon=$epsilon\n" if DEBUG;
-
- undef $table;
-
- # And for each possible rational in the table,
- # see if it is within epsilon of the input.
- foreach my $official
- (keys %utf8::nv_floating_to_rational)
- {
- print STDERR __LINE__, ": epsilon=$epsilon, official=$official, diff=", abs($parts[0] - $official), "\n" if DEBUG;
- if (abs($parts[0] - $official) < $epsilon) {
- $table =
- $utf8::nv_floating_to_rational{$official};
- last;
- }
- }
+ my $float = sprintf "%.*e",
+ $utf8::e_precision,
+ 0 + $parts[0];
- # Quit if didn't find one.
- if (! defined $table) {
- pop @recursed if @recursed;
- return $type;
- }
+ if (exists $utf8::nv_floating_to_rational{$float}) {
+ $table = $utf8::nv_floating_to_rational{$float};
+ } else {
+ pop @recursed if @recursed;
+ return $type;
}
}
print STDERR __LINE__, ": $property=$table\n" if DEBUG;
# If didn't find it, try again with looser matching by editing
# out the applicable characters on the rhs and looking up
# again.
+ my $strict_property_and_table;
if (! defined $file) {
+
+ # This isn't used unless the name begins with 'to'
+ $strict_property_and_table = $property_and_table =~ s/^to//r;
$table = _loose_name($table);
$property_and_table = "$prefix$table";
print STDERR __LINE__, ": $property_and_table\n" if DEBUG;
# Add the constant and go fetch it in.
if (defined $file) {
- # A beginning ! means to invert
- $invert_it = $file =~ s/^!//;
+ # If the file name contains a !, it means to invert. The
+ # 0+ makes sure result is numeric
+ $invert_it = 0 + $file =~ s/!//;
if ($utf8::why_deprecated{$file}) {
warnings::warnif('deprecated', "Use of '$type' in \\p{} or \\P{} is deprecated because: $utf8::why_deprecated{$file};");
{
$file = $utf8::caseless_equivalent{$property_and_table};
}
- $file= "$unicore_dir/lib/$file.pl";
+
+ # The pseudo-directory '#' means that there really isn't a
+ # file to read, the data is in-line as part of the string;
+ # we extract it below.
+ $file = "$unicore_dir/lib/$file.pl" unless $file =~ m!^#/!;
last GETFILE;
}
print STDERR __LINE__, ": didn't find $property_and_table\n" if DEBUG;
## is to use Unicode::UCD.
##
# Only check if caller wants non-binary
- my $retried = 0;
- if ($minbits != 1 && $property_and_table =~ s/^to//) {{
+ if ($minbits != 1) {
+ if ($property_and_table =~ s/^to//) {
# Look input up in list of properties for which we have
- # mapping files.
- if (defined ($file =
+ # mapping files. First do it with the strict approach
+ if (defined ($file = $utf8::strict_property_to_file_of{
+ $strict_property_and_table}))
+ {
+ $type = $utf8::file_to_swash_name{$file};
+ print STDERR __LINE__, ": type set to $type\n"
+ if DEBUG;
+ $file = "$unicore_dir/$file.pl";
+ last GETFILE;
+ }
+ elsif (defined ($file =
$utf8::loose_property_to_file_of{$property_and_table}))
- {
- $type = $utf8::file_to_swash_name{$file};
- 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}))
- {
+ {
+ $type = $utf8::file_to_swash_name{$file};
+ 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;
+ # 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, so use
+ # that, treating this as a binary property.
+ # Setting 'minbits' 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;
+
+ # The 0+ makes sure is numeric
+ $invert_it = 0 + $file =~ s/!//;
+ $file = "$unicore_dir/lib/$file.pl"
+ unless $file =~ m!^#/!;
+ last GETFILE;
+ }
}
- } }
+ }
##
## If we reach this line, it's because we couldn't figure
## If we reach here, it was due to a 'last GETFILE' above
## (exception: user-defined properties and mappings), so we
## have a filename, so now we load it if we haven't already.
- ## If we have, return the cached results. The cache key is the
- ## class and file to load.
- ##
- my $found = $Cache{$class, $file};
- if ($found and ref($found) eq $class) {
- print STDERR __LINE__, ": Returning cached '$file' for \\p{$type}; invert_it=$invert_it\n" if DEBUG;
- pop @recursed if @recursed;
- $found->{'INVERT_IT'} = $invert_it;
- return $found;
+
+ # The pseudo-directory '#' means the result isn't really a
+ # file, but is in-line, with semi-colons to be turned into
+ # new-lines. Since it is in-line there is no advantage to
+ # caching the result
+ if ($file =~ s!^#/!!) {
+ $list = $utf8::inline_definitions[$file];
+ }
+ else {
+ # Here, we have an actual file to read in and load, but it
+ # may already have been read-in and cached. The cache key
+ # is the class and file to load, and whether the results
+ # need to be inverted.
+ my $found = $Cache{$class, $file, $invert_it};
+ if ($found and ref($found) eq $class) {
+ print STDERR __LINE__, ": Returning cached swash for '$class,$file,$invert_it' for \\p{$type}\n" if DEBUG;
+ pop @recursed if @recursed;
+ return $found;
+ }
+
+ local $@;
+ local $!;
+ $list = do $file; die $@ if $@;
}
- local $@;
- local $!;
- $list = do $file; die $@ if $@;
$list_is_from_mktables = 1;
}
} # End of $type is non-null
if ($list && ! $list_is_from_mktables) {
my $taint = substr($list,0,0); # maintain taint
- # Separate the extras from the code point list, and for
- # user-defined properties, make sure the latter are well-behaved
- # for downstream code.
- if ($user_defined) {
+ # Separate the extras from the code point list, and make sure
+ # user-defined properties and tr/// are well-behaved for
+ # downstream code.
+ if ($user_defined || $none) {
my @tmp = split(/^/m, $list);
my %seen;
no warnings;
$list = join '', $taint,
map { $_->[1] }
sort { $a->[0] <=> $b->[0] }
- map { /^([0-9a-fA-F]+)/; [ CORE::hex($1), $_ ] }
- grep { /^([0-9a-fA-F]+)/ and not $seen{$1}++ } @tmp; # XXX doesn't do ranges right
+ map { /^([0-9a-fA-F]+)/ && !$seen{$1}++ ? [ CORE::hex($1), $_ ] : () }
+ @tmp; # XXX doesn't do ranges right
}
else {
# mktables has gone to some trouble to make non-user defined
} => $class;
if ($file) {
- $Cache{$class, $file} = $SWASH;
+ $Cache{$class, $file, $invert_it} = $SWASH;
if ($type
&& exists $utf8::SwashInfo{$type}
&& exists $utf8::SwashInfo{$type}{'specials_name'})
https://perl5.git.perl.org / perl5.git / blobdiff