| 1 |
package Locale::Maketext; |
| 2 |
use strict; |
| 3 |
our $USE_LITERALS; |
| 4 |
use Carp (); |
| 5 |
use I18N::LangTags (); |
| 6 |
use I18N::LangTags::Detect (); |
| 7 |
|
| 8 |
#-------------------------------------------------------------------------- |
| 9 |
|
| 10 |
BEGIN { unless(defined &DEBUG) { *DEBUG = sub () {0} } } |
| 11 |
# define the constant 'DEBUG' at compile-time |
| 12 |
|
| 13 |
# turn on utf8 if we have it (this is what GutsLoader.pm used to do essentially ) |
| 14 |
# use if (exists $INC{'utf8.pm'} || eval 'use utf8'), 'utf8'; |
| 15 |
BEGIN { |
| 16 |
|
| 17 |
# if we have it || we can load it |
| 18 |
if ( exists $INC{'utf8.pm'} || eval { local $SIG{'__DIE__'};require utf8; } ) { |
| 19 |
utf8->import(); |
| 20 |
DEBUG and warn " utf8 on for _compile()\n"; |
| 21 |
} |
| 22 |
else { |
| 23 |
DEBUG and warn " utf8 not available for _compile() ($INC{'utf8.pm'})\n$@\n"; |
| 24 |
} |
| 25 |
} |
| 26 |
|
| 27 |
|
| 28 |
our $VERSION = '1.33'; |
| 29 |
our @ISA = (); |
| 30 |
|
| 31 |
our $MATCH_SUPERS = 1; |
| 32 |
our $MATCH_SUPERS_TIGHTLY = 1; |
| 33 |
our $USING_LANGUAGE_TAGS = 1; |
| 34 |
# Turning this off is somewhat of a security risk in that little or no |
| 35 |
# checking will be done on the legality of tokens passed to the |
| 36 |
# eval("use $module_name") in _try_use. If you turn this off, you have |
| 37 |
# to do your own taint checking. |
| 38 |
|
| 39 |
$USE_LITERALS = 1 unless defined $USE_LITERALS; |
| 40 |
# a hint for compiling bracket-notation things. |
| 41 |
|
| 42 |
my %isa_scan = (); |
| 43 |
|
| 44 |
########################################################################### |
| 45 |
|
| 46 |
sub quant { |
| 47 |
my($handle, $num, @forms) = @_; |
| 48 |
|
| 49 |
return $num if @forms == 0; # what should this mean? |
| 50 |
return $forms[2] if @forms > 2 and $num == 0; # special zeroth case |
| 51 |
|
| 52 |
# Normal case: |
| 53 |
# Note that the formatting of $num is preserved. |
| 54 |
return( $handle->numf($num) . ' ' . $handle->numerate($num, @forms) ); |
| 55 |
# Most human languages put the number phrase before the qualified phrase. |
| 56 |
} |
| 57 |
|
| 58 |
|
| 59 |
sub numerate { |
| 60 |
# return this lexical item in a form appropriate to this number |
| 61 |
my($handle, $num, @forms) = @_; |
| 62 |
my $s = ($num == 1); |
| 63 |
|
| 64 |
return '' unless @forms; |
| 65 |
if(@forms == 1) { # only the headword form specified |
| 66 |
return $s ? $forms[0] : ($forms[0] . 's'); # very cheap hack. |
| 67 |
} |
| 68 |
else { # sing and plural were specified |
| 69 |
return $s ? $forms[0] : $forms[1]; |
| 70 |
} |
| 71 |
} |
| 72 |
|
| 73 |
#-------------------------------------------------------------------------- |
| 74 |
|
| 75 |
sub numf { |
| 76 |
my($handle, $num) = @_[0,1]; |
| 77 |
if($num < 10_000_000_000 and $num > -10_000_000_000 and $num == int($num)) { |
| 78 |
$num += 0; # Just use normal integer stringification. |
| 79 |
# Specifically, don't let %G turn ten million into 1E+007 |
| 80 |
} |
| 81 |
else { |
| 82 |
$num = CORE::sprintf('%G', $num); |
| 83 |
# "CORE::" is there to avoid confusion with the above sub sprintf. |
| 84 |
} |
| 85 |
while( $num =~ s/^([-+]?\d+)(\d{3})/$1,$2/s ) {1} # right from perlfaq5 |
| 86 |
# The initial \d+ gobbles as many digits as it can, and then we |
| 87 |
# backtrack so it un-eats the rightmost three, and then we |
| 88 |
# insert the comma there. |
| 89 |
|
| 90 |
$num =~ tr<.,><,.> if ref($handle) and $handle->{'numf_comma'}; |
| 91 |
# This is just a lame hack instead of using Number::Format |
| 92 |
return $num; |
| 93 |
} |
| 94 |
|
| 95 |
sub sprintf { |
| 96 |
no integer; |
| 97 |
my($handle, $format, @params) = @_; |
| 98 |
return CORE::sprintf($format, @params); |
| 99 |
# "CORE::" is there to avoid confusion with myself! |
| 100 |
} |
| 101 |
|
| 102 |
#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=# |
| 103 |
|
| 104 |
use integer; # vroom vroom... applies to the whole rest of the module |
| 105 |
|
| 106 |
sub language_tag { |
| 107 |
my $it = ref($_[0]) || $_[0]; |
| 108 |
return undef unless $it =~ m/([^':]+)(?:::)?$/s; |
| 109 |
$it = lc($1); |
| 110 |
$it =~ tr<_><->; |
| 111 |
return $it; |
| 112 |
} |
| 113 |
|
| 114 |
sub encoding { |
| 115 |
my $it = $_[0]; |
| 116 |
return( |
| 117 |
(ref($it) && $it->{'encoding'}) |
| 118 |
|| 'iso-8859-1' # Latin-1 |
| 119 |
); |
| 120 |
} |
| 121 |
|
| 122 |
#-------------------------------------------------------------------------- |
| 123 |
|
| 124 |
sub fallback_languages { return('i-default', 'en', 'en-US') } |
| 125 |
|
| 126 |
sub fallback_language_classes { return () } |
| 127 |
|
| 128 |
#-------------------------------------------------------------------------- |
| 129 |
|
| 130 |
sub fail_with { # an actual attribute method! |
| 131 |
my($handle, @params) = @_; |
| 132 |
return unless ref($handle); |
| 133 |
$handle->{'fail'} = $params[0] if @params; |
| 134 |
return $handle->{'fail'}; |
| 135 |
} |
| 136 |
|
| 137 |
#-------------------------------------------------------------------------- |
| 138 |
|
| 139 |
sub _exclude { |
| 140 |
my ( $handle, @methods ) = @_; |
| 141 |
|
| 142 |
unless ( defined $handle->{'denylist'} ) { |
| 143 |
no strict 'refs'; |
| 144 |
|
| 145 |
# Don't let people call methods they're not supposed to from maketext. |
| 146 |
# Explicitly exclude all methods in this package that start with an |
| 147 |
# underscore on principle. |
| 148 |
$handle->{'denylist'} = { |
| 149 |
map { $_ => 1 } ( |
| 150 |
qw/ |
| 151 |
blacklist |
| 152 |
denylist |
| 153 |
encoding |
| 154 |
fail_with |
| 155 |
failure_handler_auto |
| 156 |
fallback_language_classes |
| 157 |
fallback_languages |
| 158 |
get_handle |
| 159 |
init |
| 160 |
language_tag |
| 161 |
maketext |
| 162 |
new |
| 163 |
whitelist |
| 164 |
allowlist |
| 165 |
/, grep { /^_/ } keys %{ __PACKAGE__ . "::" } |
| 166 |
), |
| 167 |
}; |
| 168 |
} |
| 169 |
|
| 170 |
if ( scalar @methods ) { |
| 171 |
$handle->{'denylist'} = { %{ $handle->{'denylist'} }, map { $_ => 1 } @methods }; |
| 172 |
} |
| 173 |
|
| 174 |
delete $handle->{'_external_lex_cache'}; |
| 175 |
return; |
| 176 |
} |
| 177 |
|
| 178 |
sub blacklist { |
| 179 |
my ( $handle, @methods ) = @_; |
| 180 |
_exclude ( $handle, @methods ); |
| 181 |
return; |
| 182 |
} |
| 183 |
|
| 184 |
sub denylist { |
| 185 |
my ( $handle, @methods ) = @_; |
| 186 |
_exclude ( $handle, @methods ); |
| 187 |
return; |
| 188 |
} |
| 189 |
|
| 190 |
sub _include { |
| 191 |
my ( $handle, @methods ) = @_; |
| 192 |
if ( scalar @methods ) { |
| 193 |
$handle->{'allowlist'} = {} unless defined $handle->{'allowlist'}; |
| 194 |
$handle->{'allowlist'} = { %{ $handle->{'allowlist'} }, map { $_ => 1 } @methods }; |
| 195 |
} |
| 196 |
|
| 197 |
delete $handle->{'_external_lex_cache'}; |
| 198 |
return; |
| 199 |
} |
| 200 |
|
| 201 |
sub whitelist { |
| 202 |
my ( $handle, @methods ) = @_; |
| 203 |
_include ( $handle, @methods ); |
| 204 |
return; |
| 205 |
} |
| 206 |
|
| 207 |
sub allowlist { |
| 208 |
my ( $handle, @methods ) = @_; |
| 209 |
_include ( $handle, @methods ); |
| 210 |
return; |
| 211 |
} |
| 212 |
|
| 213 |
#-------------------------------------------------------------------------- |
| 214 |
|
| 215 |
sub failure_handler_auto { |
| 216 |
# Meant to be used like: |
| 217 |
# $handle->fail_with('failure_handler_auto') |
| 218 |
|
| 219 |
my $handle = shift; |
| 220 |
my $phrase = shift; |
| 221 |
|
| 222 |
$handle->{'failure_lex'} ||= {}; |
| 223 |
my $lex = $handle->{'failure_lex'}; |
| 224 |
|
| 225 |
my $value ||= ($lex->{$phrase} ||= $handle->_compile($phrase)); |
| 226 |
|
| 227 |
# Dumbly copied from sub maketext: |
| 228 |
return ${$value} if ref($value) eq 'SCALAR'; |
| 229 |
return $value if ref($value) ne 'CODE'; |
| 230 |
{ |
| 231 |
local $SIG{'__DIE__'}; |
| 232 |
eval { $value = &$value($handle, @_) }; |
| 233 |
} |
| 234 |
# If we make it here, there was an exception thrown in the |
| 235 |
# call to $value, and so scream: |
| 236 |
if($@) { |
| 237 |
# pretty up the error message |
| 238 |
$@ =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?} |
| 239 |
{\n in bracket code [compiled line $1],}s; |
| 240 |
#$err =~ s/\n?$/\n/s; |
| 241 |
Carp::croak "Error in maketexting \"$phrase\":\n$@ as used"; |
| 242 |
# Rather unexpected, but suppose that the sub tried calling |
| 243 |
# a method that didn't exist. |
| 244 |
} |
| 245 |
else { |
| 246 |
return $value; |
| 247 |
} |
| 248 |
} |
| 249 |
|
| 250 |
#========================================================================== |
| 251 |
|
| 252 |
sub new { |
| 253 |
# Nothing fancy! |
| 254 |
my $class = ref($_[0]) || $_[0]; |
| 255 |
my $handle = bless {}, $class; |
| 256 |
$handle->blacklist; |
| 257 |
$handle->denylist; |
| 258 |
$handle->init; |
| 259 |
return $handle; |
| 260 |
} |
| 261 |
|
| 262 |
sub init { return } # no-op |
| 263 |
|
| 264 |
########################################################################### |
| 265 |
|
| 266 |
sub maketext { |
| 267 |
# Remember, this can fail. Failure is controllable many ways. |
| 268 |
Carp::croak 'maketext requires at least one parameter' unless @_ > 1; |
| 269 |
|
| 270 |
my($handle, $phrase) = splice(@_,0,2); |
| 271 |
Carp::confess('No handle/phrase') unless (defined($handle) && defined($phrase)); |
| 272 |
|
| 273 |
# backup $@ in case it's still being used in the calling code. |
| 274 |
# If no failures, we'll re-set it back to what it was later. |
| 275 |
my $at = $@; |
| 276 |
|
| 277 |
# Copy @_ case one of its elements is $@. |
| 278 |
@_ = @_; |
| 279 |
|
| 280 |
# Look up the value: |
| 281 |
|
| 282 |
my $value; |
| 283 |
if (exists $handle->{'_external_lex_cache'}{$phrase}) { |
| 284 |
DEBUG and warn "* Using external lex cache version of \"$phrase\"\n"; |
| 285 |
$value = $handle->{'_external_lex_cache'}{$phrase}; |
| 286 |
} |
| 287 |
else { |
| 288 |
foreach my $h_r ( |
| 289 |
@{ $isa_scan{ref($handle) || $handle} || $handle->_lex_refs } |
| 290 |
) { |
| 291 |
DEBUG and warn "* Looking up \"$phrase\" in $h_r\n"; |
| 292 |
if(exists $h_r->{$phrase}) { |
| 293 |
DEBUG and warn " Found \"$phrase\" in $h_r\n"; |
| 294 |
unless(ref($value = $h_r->{$phrase})) { |
| 295 |
# Nonref means it's not yet compiled. Compile and replace. |
| 296 |
if ($handle->{'use_external_lex_cache'}) { |
| 297 |
$value = $handle->{'_external_lex_cache'}{$phrase} = $handle->_compile($value); |
| 298 |
} |
| 299 |
else { |
| 300 |
$value = $h_r->{$phrase} = $handle->_compile($value); |
| 301 |
} |
| 302 |
} |
| 303 |
last; |
| 304 |
} |
| 305 |
# extending packages need to be able to localize _AUTO and if readonly can't "local $h_r->{'_AUTO'} = 1;" |
| 306 |
# but they can "local $handle->{'_external_lex_cache'}{'_AUTO'} = 1;" |
| 307 |
elsif($phrase !~ m/^_/s and ($handle->{'use_external_lex_cache'} ? ( exists $handle->{'_external_lex_cache'}{'_AUTO'} ? $handle->{'_external_lex_cache'}{'_AUTO'} : $h_r->{'_AUTO'} ) : $h_r->{'_AUTO'})) { |
| 308 |
# it's an auto lex, and this is an autoable key! |
| 309 |
DEBUG and warn " Automaking \"$phrase\" into $h_r\n"; |
| 310 |
if ($handle->{'use_external_lex_cache'}) { |
| 311 |
$value = $handle->{'_external_lex_cache'}{$phrase} = $handle->_compile($phrase); |
| 312 |
} |
| 313 |
else { |
| 314 |
$value = $h_r->{$phrase} = $handle->_compile($phrase); |
| 315 |
} |
| 316 |
last; |
| 317 |
} |
| 318 |
DEBUG>1 and print " Not found in $h_r, nor automakable\n"; |
| 319 |
# else keep looking |
| 320 |
} |
| 321 |
} |
| 322 |
|
| 323 |
unless(defined($value)) { |
| 324 |
DEBUG and warn "! Lookup of \"$phrase\" in/under ", ref($handle) || $handle, " fails.\n"; |
| 325 |
if(ref($handle) and $handle->{'fail'}) { |
| 326 |
DEBUG and warn "WARNING0: maketext fails looking for <$phrase>\n"; |
| 327 |
my $fail; |
| 328 |
if(ref($fail = $handle->{'fail'}) eq 'CODE') { # it's a sub reference |
| 329 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 330 |
return &{$fail}($handle, $phrase, @_); |
| 331 |
# If it ever returns, it should return a good value. |
| 332 |
} |
| 333 |
else { # It's a method name |
| 334 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 335 |
return $handle->$fail($phrase, @_); |
| 336 |
# If it ever returns, it should return a good value. |
| 337 |
} |
| 338 |
} |
| 339 |
else { |
| 340 |
# All we know how to do is this; |
| 341 |
Carp::croak("maketext doesn't know how to say:\n$phrase\nas needed"); |
| 342 |
} |
| 343 |
} |
| 344 |
|
| 345 |
if(ref($value) eq 'SCALAR'){ |
| 346 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 347 |
return $$value ; |
| 348 |
} |
| 349 |
if(ref($value) ne 'CODE'){ |
| 350 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 351 |
return $value ; |
| 352 |
} |
| 353 |
|
| 354 |
{ |
| 355 |
local $SIG{'__DIE__'}; |
| 356 |
eval { $value = &$value($handle, @_) }; |
| 357 |
} |
| 358 |
# If we make it here, there was an exception thrown in the |
| 359 |
# call to $value, and so scream: |
| 360 |
if ($@) { |
| 361 |
# pretty up the error message |
| 362 |
$@ =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?} |
| 363 |
{\n in bracket code [compiled line $1],}s; |
| 364 |
#$err =~ s/\n?$/\n/s; |
| 365 |
Carp::croak "Error in maketexting \"$phrase\":\n$@ as used"; |
| 366 |
# Rather unexpected, but suppose that the sub tried calling |
| 367 |
# a method that didn't exist. |
| 368 |
} |
| 369 |
else { |
| 370 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 371 |
return $value; |
| 372 |
} |
| 373 |
$@ = $at; # Put $@ back in case we altered it along the way. |
| 374 |
} |
| 375 |
|
| 376 |
########################################################################### |
| 377 |
|
| 378 |
sub get_handle { # This is a constructor and, yes, it CAN FAIL. |
| 379 |
# Its class argument has to be the base class for the current |
| 380 |
# application's l10n files. |
| 381 |
|
| 382 |
my($base_class, @languages) = @_; |
| 383 |
$base_class = ref($base_class) || $base_class; |
| 384 |
# Complain if they use __PACKAGE__ as a project base class? |
| 385 |
|
| 386 |
if( @languages ) { |
| 387 |
DEBUG and warn 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 388 |
if($USING_LANGUAGE_TAGS) { # An explicit language-list was given! |
| 389 |
@languages = |
| 390 |
map {; $_, I18N::LangTags::alternate_language_tags($_) } |
| 391 |
# Catch alternation |
| 392 |
map I18N::LangTags::locale2language_tag($_), |
| 393 |
# If it's a lg tag, fine, pass thru (untainted) |
| 394 |
# If it's a locale ID, try converting to a lg tag (untainted), |
| 395 |
# otherwise nix it. |
| 396 |
@languages; |
| 397 |
DEBUG and warn 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 398 |
} |
| 399 |
} |
| 400 |
else { |
| 401 |
@languages = $base_class->_ambient_langprefs; |
| 402 |
} |
| 403 |
|
| 404 |
@languages = $base_class->_langtag_munging(@languages); |
| 405 |
|
| 406 |
my %seen; |
| 407 |
foreach my $module_name ( map { $base_class . '::' . $_ } @languages ) { |
| 408 |
next unless length $module_name; # sanity |
| 409 |
next if $seen{$module_name}++ # Already been here, and it was no-go |
| 410 |
|| !&_try_use($module_name); # Try to use() it, but can't it. |
| 411 |
return($module_name->new); # Make it! |
| 412 |
} |
| 413 |
|
| 414 |
return undef; # Fail! |
| 415 |
} |
| 416 |
|
| 417 |
########################################################################### |
| 418 |
|
| 419 |
sub _langtag_munging { |
| 420 |
my($base_class, @languages) = @_; |
| 421 |
|
| 422 |
# We have all these DEBUG statements because otherwise it's hard as hell |
| 423 |
# to diagnose if/when something goes wrong. |
| 424 |
|
| 425 |
DEBUG and warn 'Lgs1: ', map("<$_>", @languages), "\n"; |
| 426 |
|
| 427 |
if($USING_LANGUAGE_TAGS) { |
| 428 |
DEBUG and warn 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 429 |
@languages = $base_class->_add_supers( @languages ); |
| 430 |
|
| 431 |
push @languages, I18N::LangTags::panic_languages(@languages); |
| 432 |
DEBUG and warn "After adding panic languages:\n", |
| 433 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 434 |
|
| 435 |
push @languages, $base_class->fallback_languages; |
| 436 |
# You are free to override fallback_languages to return empty-list! |
| 437 |
DEBUG and warn 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 438 |
|
| 439 |
@languages = # final bit of processing to turn them into classname things |
| 440 |
map { |
| 441 |
my $it = $_; # copy |
| 442 |
$it =~ tr<-A-Z><_a-z>; # lc, and turn - to _ |
| 443 |
$it =~ tr<_a-z0-9><>cd; # remove all but a-z0-9_ |
| 444 |
$it; |
| 445 |
} @languages |
| 446 |
; |
| 447 |
DEBUG and warn "Nearing end of munging:\n", |
| 448 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 449 |
} |
| 450 |
else { |
| 451 |
DEBUG and warn "Bypassing language-tags.\n", |
| 452 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 453 |
} |
| 454 |
|
| 455 |
DEBUG and warn "Before adding fallback classes:\n", |
| 456 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 457 |
|
| 458 |
push @languages, $base_class->fallback_language_classes; |
| 459 |
# You are free to override that to return whatever. |
| 460 |
|
| 461 |
DEBUG and warn "Finally:\n", |
| 462 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 463 |
|
| 464 |
return @languages; |
| 465 |
} |
| 466 |
|
| 467 |
########################################################################### |
| 468 |
|
| 469 |
sub _ambient_langprefs { |
| 470 |
return I18N::LangTags::Detect::detect(); |
| 471 |
} |
| 472 |
|
| 473 |
########################################################################### |
| 474 |
|
| 475 |
sub _add_supers { |
| 476 |
my($base_class, @languages) = @_; |
| 477 |
|
| 478 |
if (!$MATCH_SUPERS) { |
| 479 |
# Nothing |
| 480 |
DEBUG and warn "Bypassing any super-matching.\n", |
| 481 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 482 |
|
| 483 |
} |
| 484 |
elsif( $MATCH_SUPERS_TIGHTLY ) { |
| 485 |
DEBUG and warn "Before adding new supers tightly:\n", |
| 486 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 487 |
@languages = I18N::LangTags::implicate_supers( @languages ); |
| 488 |
DEBUG and warn "After adding new supers tightly:\n", |
| 489 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 490 |
|
| 491 |
} |
| 492 |
else { |
| 493 |
DEBUG and warn "Before adding supers to end:\n", |
| 494 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 495 |
@languages = I18N::LangTags::implicate_supers_strictly( @languages ); |
| 496 |
DEBUG and warn "After adding supers to end:\n", |
| 497 |
' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n"; |
| 498 |
} |
| 499 |
|
| 500 |
return @languages; |
| 501 |
} |
| 502 |
|
| 503 |
########################################################################### |
| 504 |
# |
| 505 |
# This is where most people should stop reading. |
| 506 |
# |
| 507 |
########################################################################### |
| 508 |
|
| 509 |
my %tried = (); |
| 510 |
# memoization of whether we've used this module, or found it unusable. |
| 511 |
|
| 512 |
sub _try_use { # Basically a wrapper around "require Modulename" |
| 513 |
# "Many men have tried..." "They tried and failed?" "They tried and died." |
| 514 |
return $tried{$_[0]} if exists $tried{$_[0]}; # memoization |
| 515 |
|
| 516 |
my $module = $_[0]; # ASSUME sane module name! |
| 517 |
{ no strict 'refs'; |
| 518 |
no warnings 'once'; |
| 519 |
return($tried{$module} = 1) |
| 520 |
if %{$module . '::Lexicon'} or @{$module . '::ISA'}; |
| 521 |
# weird case: we never use'd it, but there it is! |
| 522 |
} |
| 523 |
|
| 524 |
DEBUG and warn " About to use $module ...\n"; |
| 525 |
|
| 526 |
local $SIG{'__DIE__'}; |
| 527 |
local $@; |
| 528 |
local @INC = @INC; |
| 529 |
pop @INC if $INC[-1] eq '.'; |
| 530 |
eval "require $module"; # used to be "use $module", but no point in that. |
| 531 |
|
| 532 |
if($@) { |
| 533 |
DEBUG and warn "Error using $module \: $@\n"; |
| 534 |
return $tried{$module} = 0; |
| 535 |
} |
| 536 |
else { |
| 537 |
DEBUG and warn " OK, $module is used\n"; |
| 538 |
return $tried{$module} = 1; |
| 539 |
} |
| 540 |
} |
| 541 |
|
| 542 |
#-------------------------------------------------------------------------- |
| 543 |
|
| 544 |
sub _lex_refs { # report the lexicon references for this handle's class |
| 545 |
# returns an arrayREF! |
| 546 |
no strict 'refs'; |
| 547 |
no warnings 'once'; |
| 548 |
my $class = ref($_[0]) || $_[0]; |
| 549 |
DEBUG and warn "Lex refs lookup on $class\n"; |
| 550 |
return $isa_scan{$class} if exists $isa_scan{$class}; # memoization! |
| 551 |
|
| 552 |
my @lex_refs; |
| 553 |
my $seen_r = ref($_[1]) ? $_[1] : {}; |
| 554 |
|
| 555 |
if( defined( *{$class . '::Lexicon'}{'HASH'} )) { |
| 556 |
push @lex_refs, *{$class . '::Lexicon'}{'HASH'}; |
| 557 |
DEBUG and warn '%' . $class . '::Lexicon contains ', |
| 558 |
scalar(keys %{$class . '::Lexicon'}), " entries\n"; |
| 559 |
} |
| 560 |
|
| 561 |
# Implements depth(height?)-first recursive searching of superclasses. |
| 562 |
# In hindsight, I suppose I could have just used Class::ISA! |
| 563 |
foreach my $superclass (@{$class . '::ISA'}) { |
| 564 |
DEBUG and warn " Super-class search into $superclass\n"; |
| 565 |
next if $seen_r->{$superclass}++; |
| 566 |
push @lex_refs, @{&_lex_refs($superclass, $seen_r)}; # call myself |
| 567 |
} |
| 568 |
|
| 569 |
$isa_scan{$class} = \@lex_refs; # save for next time |
| 570 |
return \@lex_refs; |
| 571 |
} |
| 572 |
|
| 573 |
sub clear_isa_scan { %isa_scan = (); return; } # end on a note of simplicity! |
| 574 |
|
| 575 |
#-------------------------------------------------------------------------- |
| 576 |
|
| 577 |
sub _compile { |
| 578 |
# This big scary routine compiles an entry. |
| 579 |
# It returns either a coderef if there's brackety bits in this, or |
| 580 |
# otherwise a ref to a scalar. |
| 581 |
|
| 582 |
my $string_to_compile = $_[1]; # There are taint issues using regex on @_ - perlbug 60378,27344 |
| 583 |
|
| 584 |
# The while() regex is more expensive than this check on strings that don't need a compile. |
| 585 |
# this op causes a ~2% speed hit for strings that need compile and a 250% speed improvement |
| 586 |
# on strings that don't need compiling. |
| 587 |
return \"$string_to_compile" if($string_to_compile !~ m/[\[~\]]/ms); # return a string ref if chars [~] are not in the string |
| 588 |
|
| 589 |
my $handle = $_[0]; |
| 590 |
|
| 591 |
my(@code); |
| 592 |
my(@c) = (''); # "chunks" -- scratch. |
| 593 |
my $call_count = 0; |
| 594 |
my $big_pile = ''; |
| 595 |
{ |
| 596 |
my $in_group = 0; # start out outside a group |
| 597 |
my($m, @params); # scratch |
| 598 |
|
| 599 |
while($string_to_compile =~ # Iterate over chunks. |
| 600 |
m/( |
| 601 |
[^\~\[\]]+ # non-~[] stuff (Capture everything else here) |
| 602 |
| |
| 603 |
~. # ~[, ~], ~~, ~other |
| 604 |
| |
| 605 |
\[ # [ presumably opening a group |
| 606 |
| |
| 607 |
\] # ] presumably closing a group |
| 608 |
| |
| 609 |
~ # terminal ~ ? |
| 610 |
| |
| 611 |
$ |
| 612 |
)/xgs |
| 613 |
) { |
| 614 |
DEBUG>2 and warn qq{ "$1"\n}; |
| 615 |
|
| 616 |
if($1 eq '[' or $1 eq '') { # "[" or end |
| 617 |
# Whether this is "[" or end, force processing of any |
| 618 |
# preceding literal. |
| 619 |
if($in_group) { |
| 620 |
if($1 eq '') { |
| 621 |
$handle->_die_pointing($string_to_compile, 'Unterminated bracket group'); |
| 622 |
} |
| 623 |
else { |
| 624 |
$handle->_die_pointing($string_to_compile, 'You can\'t nest bracket groups'); |
| 625 |
} |
| 626 |
} |
| 627 |
else { |
| 628 |
if ($1 eq '') { |
| 629 |
DEBUG>2 and warn " [end-string]\n"; |
| 630 |
} |
| 631 |
else { |
| 632 |
$in_group = 1; |
| 633 |
} |
| 634 |
die "How come \@c is empty?? in <$string_to_compile>" unless @c; # sanity |
| 635 |
if(length $c[-1]) { |
| 636 |
# Now actually processing the preceding literal |
| 637 |
$big_pile .= $c[-1]; |
| 638 |
if($USE_LITERALS and ( |
| 639 |
(ord('A') == 65) |
| 640 |
? $c[-1] !~ m/[^\x20-\x7E]/s |
| 641 |
# ASCII very safe chars |
| 642 |
: $c[-1] !~ m/[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~\x07]/s |
| 643 |
# EBCDIC very safe chars |
| 644 |
)) { |
| 645 |
# normal case -- all very safe chars |
| 646 |
$c[-1] =~ s/'/\\'/g; |
| 647 |
push @code, q{ '} . $c[-1] . "',\n"; |
| 648 |
$c[-1] = ''; # reuse this slot |
| 649 |
} |
| 650 |
else { |
| 651 |
$c[-1] =~ s/\\\\/\\/g; |
| 652 |
push @code, ' $c[' . $#c . "],\n"; |
| 653 |
push @c, ''; # new chunk |
| 654 |
} |
| 655 |
} |
| 656 |
# else just ignore the empty string. |
| 657 |
} |
| 658 |
|
| 659 |
} |
| 660 |
elsif($1 eq ']') { # "]" |
| 661 |
# close group -- go back in-band |
| 662 |
if($in_group) { |
| 663 |
$in_group = 0; |
| 664 |
|
| 665 |
DEBUG>2 and warn " --Closing group [$c[-1]]\n"; |
| 666 |
|
| 667 |
# And now process the group... |
| 668 |
|
| 669 |
if(!length($c[-1]) or $c[-1] =~ m/^\s+$/s) { |
| 670 |
DEBUG>2 and warn " -- (Ignoring)\n"; |
| 671 |
$c[-1] = ''; # reset out chink |
| 672 |
next; |
| 673 |
} |
| 674 |
|
| 675 |
#$c[-1] =~ s/^\s+//s; |
| 676 |
#$c[-1] =~ s/\s+$//s; |
| 677 |
($m,@params) = split(/,/, $c[-1], -1); # was /\s*,\s*/ |
| 678 |
|
| 679 |
# A bit of a hack -- we've turned "~,"'s into DELs, so turn |
| 680 |
# 'em into real commas here. |
| 681 |
if (ord('A') == 65) { # ASCII, etc |
| 682 |
foreach($m, @params) { tr/\x7F/,/ } |
| 683 |
} |
| 684 |
else { # EBCDIC (1047, 0037, POSIX-BC) |
| 685 |
# Thanks to Peter Prymmer for the EBCDIC handling |
| 686 |
foreach($m, @params) { tr/\x07/,/ } |
| 687 |
} |
| 688 |
|
| 689 |
# Special-case handling of some method names: |
| 690 |
if($m eq '_*' or $m =~ m/^_(-?\d+)$/s) { |
| 691 |
# Treat [_1,...] as [,_1,...], etc. |
| 692 |
unshift @params, $m; |
| 693 |
$m = ''; |
| 694 |
} |
| 695 |
elsif($m eq '*') { |
| 696 |
$m = 'quant'; # "*" for "times": "4 cars" is 4 times "cars" |
| 697 |
} |
| 698 |
elsif($m eq '#') { |
| 699 |
$m = 'numf'; # "#" for "number": [#,_1] for "the number _1" |
| 700 |
} |
| 701 |
|
| 702 |
# Most common case: a simple, legal-looking method name |
| 703 |
if($m eq '') { |
| 704 |
# 0-length method name means to just interpolate: |
| 705 |
push @code, ' ('; |
| 706 |
} |
| 707 |
elsif($m =~ /^\w+$/s |
| 708 |
&& !$handle->{'blacklist'}{$m} |
| 709 |
&& !$handle->{'denylist'}{$m} |
| 710 |
&& ( !defined $handle->{'whitelist'} || $handle->{'whitelist'}{$m} ) |
| 711 |
&& ( !defined $handle->{'allowlist'} || $handle->{'allowlist'}{$m} ) |
| 712 |
# exclude anything fancy and restrict to the allowlist/denylist (and historical whitelist/blacklist). |
| 713 |
) { |
| 714 |
push @code, ' $_[0]->' . $m . '('; |
| 715 |
} |
| 716 |
else { |
| 717 |
# TODO: implement something? or just too icky to consider? |
| 718 |
$handle->_die_pointing( |
| 719 |
$string_to_compile, |
| 720 |
"Can't use \"$m\" as a method name in bracket group", |
| 721 |
2 + length($c[-1]) |
| 722 |
); |
| 723 |
} |
| 724 |
|
| 725 |
pop @c; # we don't need that chunk anymore |
| 726 |
++$call_count; |
| 727 |
|
| 728 |
foreach my $p (@params) { |
| 729 |
if($p eq '_*') { |
| 730 |
# Meaning: all parameters except $_[0] |
| 731 |
$code[-1] .= ' @_[1 .. $#_], '; |
| 732 |
# and yes, that does the right thing for all @_ < 3 |
| 733 |
} |
| 734 |
elsif($p =~ m/^_(-?\d+)$/s) { |
| 735 |
# _3 meaning $_[3] |
| 736 |
$code[-1] .= '$_[' . (0 + $1) . '], '; |
| 737 |
} |
| 738 |
elsif($USE_LITERALS and ( |
| 739 |
(ord('A') == 65) |
| 740 |
? $p !~ m/[^\x20-\x7E]/s |
| 741 |
# ASCII very safe chars |
| 742 |
: $p !~ m/[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~\x07]/s |
| 743 |
# EBCDIC very safe chars |
| 744 |
)) { |
| 745 |
# Normal case: a literal containing only safe characters |
| 746 |
$p =~ s/'/\\'/g; |
| 747 |
$code[-1] .= q{'} . $p . q{', }; |
| 748 |
} |
| 749 |
else { |
| 750 |
# Stow it on the chunk-stack, and just refer to that. |
| 751 |
push @c, $p; |
| 752 |
push @code, ' $c[' . $#c . '], '; |
| 753 |
} |
| 754 |
} |
| 755 |
$code[-1] .= "),\n"; |
| 756 |
|
| 757 |
push @c, ''; |
| 758 |
} |
| 759 |
else { |
| 760 |
$handle->_die_pointing($string_to_compile, q{Unbalanced ']'}); |
| 761 |
} |
| 762 |
|
| 763 |
} |
| 764 |
elsif(substr($1,0,1) ne '~') { |
| 765 |
# it's stuff not containing "~" or "[" or "]" |
| 766 |
# i.e., a literal blob |
| 767 |
my $text = $1; |
| 768 |
$text =~ s/\\/\\\\/g; |
| 769 |
$c[-1] .= $text; |
| 770 |
|
| 771 |
} |
| 772 |
elsif($1 eq '~~') { # "~~" |
| 773 |
$c[-1] .= '~'; |
| 774 |
|
| 775 |
} |
| 776 |
elsif($1 eq '~[') { # "~[" |
| 777 |
$c[-1] .= '['; |
| 778 |
|
| 779 |
} |
| 780 |
elsif($1 eq '~]') { # "~]" |
| 781 |
$c[-1] .= ']'; |
| 782 |
|
| 783 |
} |
| 784 |
elsif($1 eq '~,') { # "~," |
| 785 |
if($in_group) { |
| 786 |
# This is a hack, based on the assumption that no-one will actually |
| 787 |
# want a DEL inside a bracket group. Let's hope that's it's true. |
| 788 |
if (ord('A') == 65) { # ASCII etc |
| 789 |
$c[-1] .= "\x7F"; |
| 790 |
} |
| 791 |
else { # EBCDIC (cp 1047, 0037, POSIX-BC) |
| 792 |
$c[-1] .= "\x07"; |
| 793 |
} |
| 794 |
} |
| 795 |
else { |
| 796 |
$c[-1] .= '~,'; |
| 797 |
} |
| 798 |
|
| 799 |
} |
| 800 |
elsif($1 eq '~') { # possible only at string-end, it seems. |
| 801 |
$c[-1] .= '~'; |
| 802 |
|
| 803 |
} |
| 804 |
else { |
| 805 |
# It's a "~X" where X is not a special character. |
| 806 |
# Consider it a literal ~ and X. |
| 807 |
my $text = $1; |
| 808 |
$text =~ s/\\/\\\\/g; |
| 809 |
$c[-1] .= $text; |
| 810 |
} |
| 811 |
} |
| 812 |
} |
| 813 |
|
| 814 |
if($call_count) { |
| 815 |
undef $big_pile; # Well, nevermind that. |
| 816 |
} |
| 817 |
else { |
| 818 |
# It's all literals! Ahwell, that can happen. |
| 819 |
# So don't bother with the eval. Return a SCALAR reference. |
| 820 |
return \$big_pile; |
| 821 |
} |
| 822 |
|
| 823 |
die q{Last chunk isn't null??} if @c and length $c[-1]; # sanity |
| 824 |
DEBUG and warn scalar(@c), " chunks under closure\n"; |
| 825 |
if(@code == 0) { # not possible? |
| 826 |
DEBUG and warn "Empty code\n"; |
| 827 |
return \''; |
| 828 |
} |
| 829 |
elsif(@code > 1) { # most cases, presumably! |
| 830 |
unshift @code, "join '',\n"; |
| 831 |
} |
| 832 |
unshift @code, "use strict; sub {\n"; |
| 833 |
push @code, "}\n"; |
| 834 |
|
| 835 |
DEBUG and warn @code; |
| 836 |
my $sub = eval(join '', @code); |
| 837 |
die "$@ while evalling" . join('', @code) if $@; # Should be impossible. |
| 838 |
return $sub; |
| 839 |
} |
| 840 |
|
| 841 |
#-------------------------------------------------------------------------- |
| 842 |
|
| 843 |
sub _die_pointing { |
| 844 |
# This is used by _compile to throw a fatal error |
| 845 |
my $target = shift; |
| 846 |
$target = ref($target) || $target; # class name |
| 847 |
# ...leaving $_[0] the error-causing text, and $_[1] the error message |
| 848 |
|
| 849 |
my $i = index($_[0], "\n"); |
| 850 |
|
| 851 |
my $pointy; |
| 852 |
my $pos = pos($_[0]) - (defined($_[2]) ? $_[2] : 0) - 1; |
| 853 |
if($pos < 1) { |
| 854 |
$pointy = "^=== near there\n"; |
| 855 |
} |
| 856 |
else { # we need to space over |
| 857 |
my $first_tab = index($_[0], "\t"); |
| 858 |
if($pos > 2 and ( -1 == $first_tab or $first_tab > pos($_[0]))) { |
| 859 |
# No tabs, or the first tab is harmlessly after where we will point to, |
| 860 |
# AND we're far enough from the margin that we can draw a proper arrow. |
| 861 |
$pointy = ('=' x $pos) . "^ near there\n"; |
| 862 |
} |
| 863 |
else { |
| 864 |
# tabs screw everything up! |
| 865 |
$pointy = substr($_[0],0,$pos); |
| 866 |
$pointy =~ tr/\t //cd; |
| 867 |
# make everything into whitespace, but preserving tabs |
| 868 |
$pointy .= "^=== near there\n"; |
| 869 |
} |
| 870 |
} |
| 871 |
|
| 872 |
my $errmsg = "$_[1], in\:\n$_[0]"; |
| 873 |
|
| 874 |
if($i == -1) { |
| 875 |
# No newline. |
| 876 |
$errmsg .= "\n" . $pointy; |
| 877 |
} |
| 878 |
elsif($i == (length($_[0]) - 1) ) { |
| 879 |
# Already has a newline at end. |
| 880 |
$errmsg .= $pointy; |
| 881 |
} |
| 882 |
else { |
| 883 |
# don't bother with the pointy bit, I guess. |
| 884 |
} |
| 885 |
Carp::croak( "$errmsg via $target, as used" ); |
| 886 |
} |
| 887 |
|
| 888 |
1; |