| Filename | /2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/5.12.3/utf8_heavy.pl |
| Statements | Executed 24693 statements in 49.0ms |
| Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
|---|---|---|---|---|---|
| 5 | 3 | 3 | 43.8ms | 52.1ms | utf8::SWASHNEW |
| 1 | 1 | 1 | 13µs | 32µs | utf8::BEGIN@383 |
| 1 | 1 | 1 | 11µs | 26µs | utf8::BEGIN@89 |
| 1 | 1 | 1 | 9µs | 11µs | utf8::BEGIN@2 |
| 1 | 1 | 1 | 7µs | 16µs | utf8::BEGIN@325 |
| 1 | 1 | 1 | 7µs | 17µs | utf8::BEGIN@3 |
| 0 | 0 | 0 | 0s | 0s | utf8::DESTROY |
| 0 | 0 | 0 | 0s | 0s | utf8::croak |
| Line | State ments |
Time on line |
Calls | Time in subs |
Code |
|---|---|---|---|---|---|
| 1 | package utf8; | ||||
| 2 | 3 | 17µs | 2 | 14µs | # spent 11µs (9+3) within utf8::BEGIN@2 which was called:
# once (9µs+3µs) by utf8::AUTOLOAD at line 2 # spent 11µs making 1 call to utf8::BEGIN@2
# spent 3µs making 1 call to strict::import |
| 3 | 3 | 218µs | 2 | 27µs | # spent 17µs (7+10) within utf8::BEGIN@3 which was called:
# once (7µs+10µs) by utf8::AUTOLOAD at line 3 # spent 17µs making 1 call to utf8::BEGIN@3
# spent 10µs making 1 call to warnings::import |
| 4 | |||||
| 5 | sub DEBUG () { 0 } | ||||
| 6 | |||||
| 7 | sub DESTROY {} | ||||
| 8 | |||||
| 9 | 1 | 200ns | my %Cache; | ||
| 10 | |||||
| 11 | sub croak { require Carp; Carp::croak(@_) } | ||||
| 12 | |||||
| 13 | ## | ||||
| 14 | ## "SWASH" == "SWATCH HASH". A "swatch" is a swatch of the Unicode landscape. | ||||
| 15 | ## It's a data structure that encodes a set of Unicode characters. | ||||
| 16 | ## | ||||
| 17 | |||||
| 18 | { | ||||
| 19 | # If a floating point number is within this distance from the value of a | ||||
| 20 | # fraction, it is considered to be that fraction, even if many more digits | ||||
| 21 | # are specified that don't exactly match. | ||||
| 22 | 2 | 900ns | my $min_floating_slop; | ||
| 23 | |||||
| 24 | # spent 52.1ms (43.8+8.30) within utf8::SWASHNEW which was called 5 times, avg 10.4ms/call:
# 3 times (43.8ms+8.28ms) by Safe::CORE:match or Safe::CORE:regcomp at line 70 of Safe.pm, avg 17.4ms/call
# once (47µs+13µs) by Package::Stash::XS::new at line 18 of utf8.pm
# once (21µs+4µs) by Package::Stash::XS::new at line 40 of Package/Stash.pm | ||||
| 25 | 24674 | 47.2ms | my ($class, $type, $list, $minbits, $none) = @_; | ||
| 26 | local $^D = 0 if $^D; | ||||
| 27 | |||||
| 28 | print STDERR __LINE__, ": ", join(", ", @_), "\n" if DEBUG; | ||||
| 29 | |||||
| 30 | ## | ||||
| 31 | ## Get the list of codepoints for the type. | ||||
| 32 | ## Called from swash_init (see utf8.c) or SWASHNEW itself. | ||||
| 33 | ## | ||||
| 34 | ## Callers of swash_init: | ||||
| 35 | ## op.c:pmtrans -- for tr/// and y/// | ||||
| 36 | ## regexec.c:regclass_swash -- for /[]/, \p, and \P | ||||
| 37 | ## utf8.c:is_utf8_common -- for common Unicode properties | ||||
| 38 | ## utf8.c:to_utf8_case -- for lc, uc, ucfirst, etc. and //i | ||||
| 39 | ## | ||||
| 40 | ## Given a $type, our goal is to fill $list with the set of codepoint | ||||
| 41 | ## ranges. If $type is false, $list passed is used. | ||||
| 42 | ## | ||||
| 43 | ## $minbits: | ||||
| 44 | ## For binary properties, $minbits must be 1. | ||||
| 45 | ## For character mappings (case and transliteration), $minbits must | ||||
| 46 | ## be a number except 1. | ||||
| 47 | ## | ||||
| 48 | ## $list (or that filled according to $type): | ||||
| 49 | ## Refer to perlunicode.pod, "User-Defined Character Properties." | ||||
| 50 | ## | ||||
| 51 | ## For binary properties, only characters with the property value | ||||
| 52 | ## of True should be listed. The 3rd column, if any, will be ignored | ||||
| 53 | ## | ||||
| 54 | ## $none is undocumented, so I'm (khw) trying to do some documentation | ||||
| 55 | ## of it now. It appears to be if there is a mapping in an input file | ||||
| 56 | ## that maps to 'XXXX', then that is replaced by $none+1, expressed in | ||||
| 57 | ## hexadecimal. The only place I found it possibly used was in | ||||
| 58 | ## S_pmtrans in op.c. | ||||
| 59 | ## | ||||
| 60 | ## To make the parsing of $type clear, this code takes the a rather | ||||
| 61 | ## unorthodox approach of last'ing out of the block once we have the | ||||
| 62 | ## info we need. Were this to be a subroutine, the 'last' would just | ||||
| 63 | ## be a 'return'. | ||||
| 64 | ## | ||||
| 65 | my $file; ## file to load data from, and also part of the %Cache key. | ||||
| 66 | my $ListSorted = 0; | ||||
| 67 | |||||
| 68 | # Change this to get a different set of Unicode tables | ||||
| 69 | my $unicore_dir = 'unicore'; | ||||
| 70 | |||||
| 71 | if ($type) | ||||
| 72 | { | ||||
| 73 | 3 | 8µs | $type =~ s/^\s+//; # spent 8µs making 3 calls to utf8::CORE:subst, avg 3µs/call | ||
| 74 | 3 | 4µs | $type =~ s/\s+$//; # spent 4µs making 3 calls to utf8::CORE:subst, avg 1µs/call | ||
| 75 | |||||
| 76 | print STDERR __LINE__, ": type = $type\n" if DEBUG; | ||||
| 77 | |||||
| 78 | 3 | 2µs | GETFILE: # spent 2µs making 3 calls to utf8::CORE:subst, avg 767ns/call | ||
| 79 | { | ||||
| 80 | ## | ||||
| 81 | ## It could be a user-defined property. | ||||
| 82 | ## | ||||
| 83 | |||||
| 84 | my $caller1 = $type =~ s/(.+)::// ? $1 : caller(1); | ||||
| 85 | |||||
| 86 | 3 | 3µs | if (defined $caller1 && $type =~ /^I[ns]\w+$/) { # spent 3µs making 3 calls to utf8::CORE:match, avg 900ns/call | ||
| 87 | my $prop = "${caller1}::$type"; | ||||
| 88 | if (exists &{$prop}) { | ||||
| 89 | 3 | 812µs | 2 | 40µs | # spent 26µs (11+15) within utf8::BEGIN@89 which was called:
# once (11µs+15µs) by utf8::AUTOLOAD at line 89 # spent 26µs making 1 call to utf8::BEGIN@89
# spent 15µs making 1 call to strict::unimport |
| 90 | |||||
| 91 | $list = &{$prop}; | ||||
| 92 | last GETFILE; | ||||
| 93 | } | ||||
| 94 | } | ||||
| 95 | |||||
| 96 | require "$unicore_dir/Heavy.pl"; | ||||
| 97 | |||||
| 98 | # Everything is caseless matching | ||||
| 99 | my $property_and_table = lc $type; | ||||
| 100 | print STDERR __LINE__, ": $property_and_table\n" if DEBUG; | ||||
| 101 | |||||
| 102 | # See if is of the compound form 'property=value', where the | ||||
| 103 | # value indicates the table we should use. | ||||
| 104 | my ($property, $table, @remainder) = | ||||
| 105 | split /\s*[:=]\s*/, $property_and_table, -1; | ||||
| 106 | return $type if @remainder; | ||||
| 107 | |||||
| 108 | my $prefix; | ||||
| 109 | if (! defined $table) { | ||||
| 110 | |||||
| 111 | # Here, is the single form. The property becomes empty, and | ||||
| 112 | # the whole value is the table. | ||||
| 113 | $table = $property; | ||||
| 114 | $prefix = $property = ""; | ||||
| 115 | } else { | ||||
| 116 | print STDERR __LINE__, ": $property\n" if DEBUG; | ||||
| 117 | |||||
| 118 | # Here it is the compound property=table form. The property | ||||
| 119 | # name is always loosely matched, which means remove any of | ||||
| 120 | # these: | ||||
| 121 | $property =~ s/[_\s-]//g; | ||||
| 122 | |||||
| 123 | # And convert to canonical form. Quit if not valid. | ||||
| 124 | $property = $utf8::loose_property_name_of{$property}; | ||||
| 125 | return $type unless defined $property; | ||||
| 126 | |||||
| 127 | $prefix = "$property="; | ||||
| 128 | |||||
| 129 | # If the rhs looks like it is a number... | ||||
| 130 | print STDERR __LINE__, ": table=$table\n" if DEBUG; | ||||
| 131 | if ($table =~ qr{ ^ [ \s 0-9 _ + / . -]+ $ }x) { | ||||
| 132 | print STDERR __LINE__, ": table=$table\n" if DEBUG; | ||||
| 133 | |||||
| 134 | # Don't allow leading nor trailing slashes | ||||
| 135 | return $type if $table =~ / ^ \/ | \/ $ /x; | ||||
| 136 | |||||
| 137 | # Split on slash, in case it is a rational, like \p{1/5} | ||||
| 138 | my @parts = split qr{ \s* / \s* }x, $table, -1; | ||||
| 139 | print __LINE__, ": $type\n" if @parts > 2 && DEBUG; | ||||
| 140 | |||||
| 141 | # Can have maximum of one slash | ||||
| 142 | return $type if @parts > 2; | ||||
| 143 | |||||
| 144 | foreach my $part (@parts) { | ||||
| 145 | print __LINE__, ": part=$part\n" if DEBUG; | ||||
| 146 | |||||
| 147 | $part =~ s/^\+\s*//; # Remove leading plus | ||||
| 148 | $part =~ s/^-\s*/-/; # Remove blanks after unary | ||||
| 149 | # minus | ||||
| 150 | |||||
| 151 | # Remove underscores between digits. | ||||
| 152 | $part =~ s/( ?<= [0-9] ) _ (?= [0-9] ) //xg; | ||||
| 153 | |||||
| 154 | # No leading zeros (but don't make a single '0' | ||||
| 155 | # into a null string) | ||||
| 156 | $part =~ s/ ^ ( -? ) 0+ /$1/x; | ||||
| 157 | $part .= '0' if $part eq '-' || $part eq ""; | ||||
| 158 | |||||
| 159 | # No trailing zeros after a decimal point | ||||
| 160 | $part =~ s/ ( \. .*? ) 0+ $ /$1/x; | ||||
| 161 | |||||
| 162 | # Begin with a 0 if a leading decimal point | ||||
| 163 | $part =~ s/ ^ ( -? ) \. /${1}0./x; | ||||
| 164 | |||||
| 165 | # Ensure not a trailing decimal point: turn into an | ||||
| 166 | # integer | ||||
| 167 | $part =~ s/ \. $ //x; | ||||
| 168 | |||||
| 169 | print STDERR __LINE__, ": part=$part\n" if DEBUG; | ||||
| 170 | #return $type if $part eq ""; | ||||
| 171 | |||||
| 172 | # Result better look like a number. (This test is | ||||
| 173 | # needed because, for example could have a plus in | ||||
| 174 | # the middle.) | ||||
| 175 | return $type if $part | ||||
| 176 | !~ / ^ -? [0-9]+ ( \. [0-9]+)? $ /x; | ||||
| 177 | } | ||||
| 178 | |||||
| 179 | # If a rational... | ||||
| 180 | if (@parts == 2) { | ||||
| 181 | |||||
| 182 | # If denominator is negative, get rid of it, and ... | ||||
| 183 | if ($parts[1] =~ s/^-//) { | ||||
| 184 | |||||
| 185 | # If numerator is also negative, convert the | ||||
| 186 | # whole thing to positive, or move the minus to | ||||
| 187 | # the numerator | ||||
| 188 | if ($parts[0] !~ s/^-//) { | ||||
| 189 | $parts[0] = '-' . $parts[0]; | ||||
| 190 | } | ||||
| 191 | } | ||||
| 192 | $table = join '/', @parts; | ||||
| 193 | } | ||||
| 194 | elsif ($property ne 'nv' || $parts[0] !~ /\./) { | ||||
| 195 | |||||
| 196 | # Here is not numeric value, or doesn't have a | ||||
| 197 | # decimal point. No further manipulation is | ||||
| 198 | # necessary. (Note the hard-coded property name. | ||||
| 199 | # This could fail if other properties eventually | ||||
| 200 | # had fractions as well; perhaps the cjk ones | ||||
| 201 | # could evolve to do that. This hard-coding could | ||||
| 202 | # be fixed by mktables generating a list of | ||||
| 203 | # properties that could have fractions.) | ||||
| 204 | $table = $parts[0]; | ||||
| 205 | } else { | ||||
| 206 | |||||
| 207 | # Here is a floating point numeric_value. Try to | ||||
| 208 | # convert to rational. First see if is in the list | ||||
| 209 | # of known ones. | ||||
| 210 | if (exists $utf8::nv_floating_to_rational{$parts[0]}) { | ||||
| 211 | $table = $utf8::nv_floating_to_rational{$parts[0]}; | ||||
| 212 | } else { | ||||
| 213 | |||||
| 214 | # Here not in the list. See if is close | ||||
| 215 | # enough to something in the list. First | ||||
| 216 | # determine what 'close enough' means. It has | ||||
| 217 | # to be as tight as what mktables says is the | ||||
| 218 | # maximum slop, and as tight as how many | ||||
| 219 | # digits we were passed. That is, if the user | ||||
| 220 | # said .667, .6667, .66667, etc. we match as | ||||
| 221 | # many digits as they passed until get to | ||||
| 222 | # where it doesn't matter any more due to the | ||||
| 223 | # machine's precision. If they said .6666668, | ||||
| 224 | # we fail. | ||||
| 225 | (my $fraction = $parts[0]) =~ s/^.*\.//; | ||||
| 226 | my $epsilon = 10 ** - (length($fraction)); | ||||
| 227 | if ($epsilon > $utf8::max_floating_slop) { | ||||
| 228 | $epsilon = $utf8::max_floating_slop; | ||||
| 229 | } | ||||
| 230 | |||||
| 231 | # But it can't be tighter than the minimum | ||||
| 232 | # precision for this machine. If haven't | ||||
| 233 | # already calculated that minimum, do so now. | ||||
| 234 | if (! defined $min_floating_slop) { | ||||
| 235 | |||||
| 236 | # Keep going down an order of magnitude | ||||
| 237 | # until find that adding this quantity to | ||||
| 238 | # 1 remains 1; but put an upper limit on | ||||
| 239 | # this so in case this algorithm doesn't | ||||
| 240 | # work properly on some platform, that we | ||||
| 241 | # won't loop forever. | ||||
| 242 | my $count = 0; | ||||
| 243 | $min_floating_slop = 1; | ||||
| 244 | while (1+ $min_floating_slop != 1 | ||||
| 245 | && $count++ < 50) | ||||
| 246 | { | ||||
| 247 | my $next = $min_floating_slop / 10; | ||||
| 248 | last if $next == 0; # If underflows, | ||||
| 249 | # use previous one | ||||
| 250 | $min_floating_slop = $next; | ||||
| 251 | print STDERR __LINE__, ": min_float_slop=$min_floating_slop\n" if DEBUG; | ||||
| 252 | } | ||||
| 253 | |||||
| 254 | # Back off a couple orders of magnitude, | ||||
| 255 | # just to be safe. | ||||
| 256 | $min_floating_slop *= 100; | ||||
| 257 | } | ||||
| 258 | |||||
| 259 | if ($epsilon < $min_floating_slop) { | ||||
| 260 | $epsilon = $min_floating_slop; | ||||
| 261 | } | ||||
| 262 | print STDERR __LINE__, ": fraction=.$fraction; epsilon=$epsilon\n" if DEBUG; | ||||
| 263 | |||||
| 264 | undef $table; | ||||
| 265 | |||||
| 266 | # And for each possible rational in the table, | ||||
| 267 | # see if it is within epsilon of the input. | ||||
| 268 | foreach my $official | ||||
| 269 | (keys %utf8::nv_floating_to_rational) | ||||
| 270 | { | ||||
| 271 | print STDERR __LINE__, ": epsilon=$epsilon, official=$official, diff=", abs($parts[0] - $official), "\n" if DEBUG; | ||||
| 272 | if (abs($parts[0] - $official) < $epsilon) { | ||||
| 273 | $table = | ||||
| 274 | $utf8::nv_floating_to_rational{$official}; | ||||
| 275 | last; | ||||
| 276 | } | ||||
| 277 | } | ||||
| 278 | |||||
| 279 | # Quit if didn't find one. | ||||
| 280 | return $type unless defined $table; | ||||
| 281 | } | ||||
| 282 | } | ||||
| 283 | print STDERR __LINE__, ": $property=$table\n" if DEBUG; | ||||
| 284 | } | ||||
| 285 | } | ||||
| 286 | |||||
| 287 | # Combine lhs (if any) and rhs to get something that matches | ||||
| 288 | # the syntax of the lookups. | ||||
| 289 | $property_and_table = "$prefix$table"; | ||||
| 290 | print STDERR __LINE__, ": $property_and_table\n" if DEBUG; | ||||
| 291 | |||||
| 292 | # First try stricter matching. | ||||
| 293 | $file = $utf8::stricter_to_file_of{$property_and_table}; | ||||
| 294 | |||||
| 295 | # If didn't find it, try again with looser matching by editing | ||||
| 296 | # out the applicable characters on the rhs and looking up | ||||
| 297 | # again. | ||||
| 298 | if (! defined $file) { | ||||
| 299 | 3 | 5µs | $table =~ s/ [_\s-] //xg; # spent 5µs making 3 calls to utf8::CORE:subst, avg 2µs/call | ||
| 300 | $property_and_table = "$prefix$table"; | ||||
| 301 | print STDERR __LINE__, ": $property_and_table\n" if DEBUG; | ||||
| 302 | $file = $utf8::loose_to_file_of{$property_and_table}; | ||||
| 303 | } | ||||
| 304 | |||||
| 305 | # Add the constant and go fetch it in. | ||||
| 306 | if (defined $file) { | ||||
| 307 | if ($utf8::why_deprecated{$file}) { | ||||
| 308 | warnings::warnif('deprecated', "Use of '$type' in \\p{} or \\P{} is deprecated because: $utf8::why_deprecated{$file};"); | ||||
| 309 | } | ||||
| 310 | $file= "$unicore_dir/lib/$file.pl"; | ||||
| 311 | last GETFILE; | ||||
| 312 | } | ||||
| 313 | print STDERR __LINE__, ": didn't find $property_and_table\n" if DEBUG; | ||||
| 314 | |||||
| 315 | ## | ||||
| 316 | ## See if it's a user-level "To". | ||||
| 317 | ## | ||||
| 318 | |||||
| 319 | my $caller0 = caller(0); | ||||
| 320 | |||||
| 321 | 3 | 11µs | if (defined $caller0 && $type =~ /^To(?:\w+)$/) { # spent 11µs making 3 calls to utf8::CORE:match, avg 4µs/call | ||
| 322 | my $map = $caller0 . "::" . $type; | ||||
| 323 | |||||
| 324 | if (exists &{$map}) { | ||||
| 325 | 3 | 200µs | 2 | 24µs | # spent 16µs (7+9) within utf8::BEGIN@325 which was called:
# once (7µs+9µs) by utf8::AUTOLOAD at line 325 # spent 16µs making 1 call to utf8::BEGIN@325
# spent 9µs making 1 call to strict::unimport |
| 326 | |||||
| 327 | $list = &{$map}; | ||||
| 328 | last GETFILE; | ||||
| 329 | } | ||||
| 330 | } | ||||
| 331 | |||||
| 332 | ## | ||||
| 333 | ## Last attempt -- see if it's a standard "To" name | ||||
| 334 | ## (e.g. "ToLower") ToTitle is used by ucfirst(). | ||||
| 335 | ## The user-level way to access ToDigit() and ToFold() | ||||
| 336 | ## is to use Unicode::UCD. | ||||
| 337 | ## | ||||
| 338 | 3 | 11µs | if ($type =~ /^To(Digit|Fold|Lower|Title|Upper)$/) { # spent 11µs making 3 calls to utf8::CORE:match, avg 4µs/call | ||
| 339 | $file = "$unicore_dir/To/$1.pl"; | ||||
| 340 | ## would like to test to see if $file actually exists.... | ||||
| 341 | last GETFILE; | ||||
| 342 | } | ||||
| 343 | |||||
| 344 | ## | ||||
| 345 | ## If we reach this line, it's because we couldn't figure | ||||
| 346 | ## out what to do with $type. Ouch. | ||||
| 347 | ## | ||||
| 348 | |||||
| 349 | return $type; | ||||
| 350 | } | ||||
| 351 | |||||
| 352 | if (defined $file) { | ||||
| 353 | print STDERR __LINE__, ": found it (file='$file')\n" if DEBUG; | ||||
| 354 | |||||
| 355 | ## | ||||
| 356 | ## If we reach here, it was due to a 'last GETFILE' above | ||||
| 357 | ## (exception: user-defined properties and mappings), so we | ||||
| 358 | ## have a filename, so now we load it if we haven't already. | ||||
| 359 | ## If we have, return the cached results. The cache key is the | ||||
| 360 | ## class and file to load. | ||||
| 361 | ## | ||||
| 362 | my $found = $Cache{$class, $file}; | ||||
| 363 | if ($found and ref($found) eq $class) { | ||||
| 364 | print STDERR __LINE__, ": Returning cached '$file' for \\p{$type}\n" if DEBUG; | ||||
| 365 | return $found; | ||||
| 366 | } | ||||
| 367 | |||||
| 368 | local $@; | ||||
| 369 | local $!; | ||||
| 370 | $list = do $file; die $@ if $@; | ||||
| 371 | } | ||||
| 372 | |||||
| 373 | $ListSorted = 1; ## we know that these lists are sorted | ||||
| 374 | } | ||||
| 375 | |||||
| 376 | my $extras; | ||||
| 377 | my $bits = $minbits; | ||||
| 378 | |||||
| 379 | my $ORIG = $list; | ||||
| 380 | if ($list) { | ||||
| 381 | my @tmp = split(/^/m, $list); | ||||
| 382 | my %seen; | ||||
| 383 | 3 | 498µs | 2 | 51µs | # spent 32µs (13+19) within utf8::BEGIN@383 which was called:
# once (13µs+19µs) by utf8::AUTOLOAD at line 383 # spent 32µs making 1 call to utf8::BEGIN@383
# spent 19µs making 1 call to warnings::unimport |
| 384 | 3053 | 935µs | $extras = join '', grep /^[^0-9a-fA-F]/, @tmp; # spent 935µs making 3053 calls to utf8::CORE:match, avg 306ns/call | ||
| 385 | $list = join '', | ||||
| 386 | map { $_->[1] } | ||||
| 387 | 3051 | 1.70ms | sort { $a->[0] <=> $b->[0] } # spent 1.70ms making 3051 calls to utf8::CORE:match, avg 556ns/call | ||
| 388 | 3053 | 1.68ms | map { /^([0-9a-fA-F]+)/; [ CORE::hex($1), $_ ] } # spent 1.68ms making 3053 calls to utf8::CORE:match, avg 550ns/call | ||
| 389 | 5 | 551µs | grep { /^([0-9a-fA-F]+)/ and not $seen{$1}++ } @tmp; # XXX doesn't do ranges right # spent 551µs making 5 calls to utf8::CORE:sort, avg 110µs/call | ||
| 390 | } | ||||
| 391 | |||||
| 392 | if ($none) { | ||||
| 393 | my $hextra = sprintf "%04x", $none + 1; | ||||
| 394 | $list =~ s/\tXXXX$/\t$hextra/mg; | ||||
| 395 | } | ||||
| 396 | |||||
| 397 | if ($minbits != 1 && $minbits < 32) { # not binary property | ||||
| 398 | my $top = 0; | ||||
| 399 | 3 | 35µs | while ($list =~ /^([0-9a-fA-F]+)(?:[\t]([0-9a-fA-F]+)?)(?:[ \t]([0-9a-fA-F]+))?/mg) { # spent 35µs making 3 calls to utf8::CORE:match, avg 12µs/call | ||
| 400 | my $min = CORE::hex $1; | ||||
| 401 | my $max = defined $2 ? CORE::hex $2 : $min; | ||||
| 402 | my $val = defined $3 ? CORE::hex $3 : 0; | ||||
| 403 | $val += $max - $min if defined $3; | ||||
| 404 | 3051 | 3.35ms | $top = $val if $val > $top; # spent 3.35ms making 3051 calls to utf8::CORE:match, avg 1µs/call | ||
| 405 | } | ||||
| 406 | my $topbits = | ||||
| 407 | $top > 0xffff ? 32 : | ||||
| 408 | $top > 0xff ? 16 : 8; | ||||
| 409 | $bits = $topbits if $bits < $topbits; | ||||
| 410 | } | ||||
| 411 | |||||
| 412 | my @extras; | ||||
| 413 | if ($extras) { | ||||
| 414 | for my $x ($extras) { | ||||
| 415 | pos $x = 0; | ||||
| 416 | 2 | 3µs | while ($x =~ /^([^0-9a-fA-F\n])(.*)/mg) { # spent 3µs making 2 calls to utf8::CORE:match, avg 1µs/call | ||
| 417 | my $char = $1; | ||||
| 418 | my $name = $2; | ||||
| 419 | print STDERR __LINE__, ": $1 => $2\n" if DEBUG; | ||||
| 420 | 4 | 3µs | if ($char =~ /[-+!&]/) { # spent 3µs making 4 calls to utf8::CORE:match, avg 650ns/call | ||
| 421 | my ($c,$t) = split(/::/, $name, 2); # bogus use of ::, really | ||||
| 422 | my $subobj; | ||||
| 423 | if ($c eq 'utf8') { | ||||
| 424 | $subobj = utf8->SWASHNEW($t, "", $minbits, 0); | ||||
| 425 | } | ||||
| 426 | elsif (exists &$name) { | ||||
| 427 | $subobj = utf8->SWASHNEW($name, "", $minbits, 0); | ||||
| 428 | } | ||||
| 429 | elsif ($c =~ /^([0-9a-fA-F]+)/) { | ||||
| 430 | $subobj = utf8->SWASHNEW("", $c, $minbits, 0); | ||||
| 431 | } | ||||
| 432 | return $subobj unless ref $subobj; | ||||
| 433 | push @extras, $name => $subobj; | ||||
| 434 | $bits = $subobj->{BITS} if $bits < $subobj->{BITS}; | ||||
| 435 | } | ||||
| 436 | } | ||||
| 437 | } | ||||
| 438 | } | ||||
| 439 | |||||
| 440 | if (DEBUG) { | ||||
| 441 | print STDERR __LINE__, ": CLASS = $class, TYPE => $type, BITS => $bits, NONE => $none"; | ||||
| 442 | print STDERR "\nLIST =>\n$list" if defined $list; | ||||
| 443 | print STDERR "\nEXTRAS =>\n$extras" if defined $extras; | ||||
| 444 | print STDERR "\n"; | ||||
| 445 | } | ||||
| 446 | |||||
| 447 | my $SWASH = bless { | ||||
| 448 | TYPE => $type, | ||||
| 449 | BITS => $bits, | ||||
| 450 | EXTRAS => $extras, | ||||
| 451 | LIST => $list, | ||||
| 452 | NONE => $none, | ||||
| 453 | @extras, | ||||
| 454 | } => $class; | ||||
| 455 | |||||
| 456 | if ($file) { | ||||
| 457 | $Cache{$class, $file} = $SWASH; | ||||
| 458 | } | ||||
| 459 | |||||
| 460 | return $SWASH; | ||||
| 461 | } | ||||
| 462 | } | ||||
| 463 | |||||
| 464 | # Now SWASHGET is recasted into a C function S_swash_get (see utf8.c). | ||||
| 465 | |||||
| 466 | 1 | 3µs | 1; |