package Locale
::Maketext
::Guts
;
BEGIN { *zorp
= sub { return scalar @_ } unless defined &zorp
; }
# Just so we're nice and define SOMETHING in "our" package.
package Locale
::Maketext
;
use vars
qw($USE_LITERALS $GUTSPATH);
*DEBUG = sub () {0} unless defined &DEBUG;
# This big scary routine compiles an entry.
# It returns either a coderef if there's brackety bits in this, or
# otherwise a ref to a scalar.
my $target = ref($_[0]) || $_[0];
my(@c) = (''); # "chunks" -- scratch.
my $in_group = 0; # start out outside a group
my($m, @params); # scratch
while($_[1] =~ # Iterate over chunks.
[^\~\[\]]+ # non-~[] stuff
\[ # [ presumably opening a group
\] # ] presumably closing a group
print " \"$1\"\n" if DEBUG > 2;
if($1 eq '[' or $1 eq '') { # "[" or end
# Whether this is "[" or end, force processing of any
$target->_die_pointing($_[1], "Unterminated bracket group");
$target->_die_pointing($_[1], "You can't nest bracket groups");
print " [end-string]\n" if DEBUG > 2;
die "How come \@c is empty?? in <$_[1]>" unless @c; # sanity
# Now actually processing the preceding literal
? $c[-1] !~ m<[^\x20-\x7E]>s
: $c[-1] !~ m/[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~\x07]/s
# normal case -- all very safe chars
push @code, q{ '} . $c[-1] . "',\n";
$c[-1] = ''; # reuse this slot
push @code, ' $c[' . $#c . "],\n";
# else just ignore the empty string.
} elsif($1 eq ']') { # "]"
# close group -- go back in-band
print " --Closing group [$c[-1]]\n" if DEBUG
> 2;
# And now process the group...
if(!length($c[-1]) or $c[-1] =~ m/^\s+$/s) {
DEBUG
> 2 and print " -- (Ignoring)\n";
$c[-1] = ''; # reset out chink
($m,@params) = split(",", $c[-1], -1); # was /\s*,\s*/
# A bit of a hack -- we've turned "~,"'s into DELs, so turn
# 'em into real commas here.
if (ord('A') == 65) { # ASCII, etc
foreach($m, @params) { tr/\x7F/,/ }
} else { # EBCDIC (1047, 0037, POSIX-BC)
# Thanks to Peter Prymmer for the EBCDIC handling
foreach($m, @params) { tr/\x07/,/ }
# Special-case handling of some method names:
if($m eq '_*' or $m =~ m
<^_
(-?\d
+)$>s
) {
# Treat [_1,...] as [,_1,...], etc.
$m = 'quant'; # "*" for "times": "4 cars" is 4 times "cars"
$m = 'numf'; # "#" for "number": [#,_1] for "the number _1"
# Most common case: a simple, legal-looking method name
# 0-length method name means to just interpolate:
} elsif($m =~ m
<^\w
+(?
:\
:\
:\w
+)*$>s
# exclude starting a (sub)package or symbol with a digit
# Yes, it even supports the demented (and undocumented?)
# $obj->Foo::bar(...) syntax.
$_[1], "Can't (yet?) use \"SUPER::\" in a bracket-group method",
# Because for SUPER:: to work, we'd have to compile this into
# the right package, and that seems just not worth the bother,
# unless someone convinces me otherwise.
push @code, ' $_[0]->' . $m . '(';
# TODO: implement something? or just too icky to consider?
"Can't use \"$m\" as a method name in bracket group",
pop @c; # we don't need that chunk anymore
foreach my $p (@params) {
# Meaning: all parameters except $_[0]
$code[-1] .= ' @_[1 .. $#_], ';
# and yes, that does the right thing for all @_ < 3
} elsif($p =~ m
<^_
(-?\d
+)$>s
) {
$code[-1] .= '$_[' . (0 + $1) . '], ';
} elsif($USE_LITERALS and (
: $p !~ m/[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\
@A-Z
[\\\
]^_
`a-z{|}~\x07]/s
# Normal case: a literal containing only safe characters
$code[-1] .= q{'} . $p . q{', };
# Stow it on the chunk-stack, and just refer to that.
push @code, ' $c[' . $#c . "], ";
$target->_die_pointing($_[1], "Unbalanced ']'");
} elsif(substr($1,0,1) ne '~') {
# it's stuff not containing "~" or "[" or "]"
} elsif($1 eq '~~') { # "~~"
} elsif($1 eq '~[') { # "~["
} elsif($1 eq '~]') { # "~]"
} elsif($1 eq '~,') { # "~,"
# This is a hack, based on the assumption that no-one will actually
# want a DEL inside a bracket group. Let's hope that's it's true.
if (ord('A') == 65) { # ASCII etc
} else { # EBCDIC (cp 1047, 0037, POSIX-BC)
} elsif($1 eq '~') { # possible only at string-end, it seems.
# It's a "~X" where X is not a special character.
# Consider it a literal ~ and X.
undef $big_pile; # Well, nevermind that.
# It's all literals! Ahwell, that can happen.
# So don't bother with the eval. Return a SCALAR reference.
die "Last chunk isn't null??" if @c and length $c[-1]; # sanity
print scalar(@c), " chunks under closure\n" if DEBUG
;
if(@code == 0) { # not possible?
print "Empty code\n" if DEBUG
;
} elsif(@code > 1) { # most cases, presumably!
unshift @code, "join '',\n";
unshift @code, "use strict; sub {\n";
my $sub = eval(join '', @code);
die "$@ while evalling" . join('', @code) if $@; # Should be impossible.
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# This is used by _compile to throw a fatal error
my $target = shift; # class name
# ...leaving $_[0] the error-causing text, and $_[1] the error message
my $i = index($_[0], "\n");
my $pos = pos($_[0]) - (defined($_[2]) ? $_[2] : 0) - 1;
$pointy = "^=== near there\n";
} else { # we need to space over
my $first_tab = index($_[0], "\t");
if($pos > 2 and ( -1 == $first_tab or $first_tab > pos($_[0]))) {
# No tabs, or the first tab is harmlessly after where we will point to,
# AND we're far enough from the margin that we can draw a proper arrow
.
$pointy = ('=' x
$pos) . "^ near there\n";
# tabs screw everything up!
$pointy = substr($_[0],0,$pos);
# make everything into whitespace, but preseving tabs
$pointy .= "^=== near there\n";
my $errmsg = "$_[1], in\:\n$_[0]";
$errmsg .= "\n" . $pointy;
} elsif($i == (length($_[0]) - 1) ) {
# Already has a newline at end.
# don't bother with the pointy bit, I guess.
Carp
::croak
( "$errmsg via $target, as used" );