

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: Maketext.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>package Locale::Maketext;
use strict;
use vars qw( @ISA $VERSION $MATCH_SUPERS $USING_LANGUAGE_TAGS
$USE_LITERALS $MATCH_SUPERS_TIGHTLY);
use Carp ();
use I18N::LangTags ();
use I18N::LangTags::Detect ();

#--------------------------------------------------------------------------

BEGIN { unless(defined &amp;DEBUG) { *DEBUG = sub () {0} } }
# define the constant &#039;DEBUG&#039; at compile-time

# turn on utf8 if we have it (this is what GutsLoader.pm used to do essentially )
#    use if (exists $INC{&#039;utf8.pm&#039;} || eval &#039;use utf8&#039;), &#039;utf8&#039;;
BEGIN {

    # if we have it || we can load it
    if ( exists $INC{&#039;utf8.pm&#039;} || eval { local $SIG{&#039;__DIE__&#039;};require utf8; } ) {
        utf8-&gt;import();
        DEBUG and warn &quot; utf8 on for _compile()\n&quot;;
    }
    else {
        DEBUG and warn &quot; utf8 not available for _compile() ($INC{&#039;utf8.pm&#039;})\n$@\n&quot;;
    }
}


$VERSION = &#039;1.28&#039;;
@ISA = ();

$MATCH_SUPERS = 1;
$MATCH_SUPERS_TIGHTLY = 1;
$USING_LANGUAGE_TAGS  = 1;
# Turning this off is somewhat of a security risk in that little or no
# checking will be done on the legality of tokens passed to the
# eval(&quot;use $module_name&quot;) in _try_use.  If you turn this off, you have
# to do your own taint checking.

$USE_LITERALS = 1 unless defined $USE_LITERALS;
# a hint for compiling bracket-notation things.

my %isa_scan = ();

###########################################################################

sub quant {
    my($handle, $num, @forms) = @_;

    return $num if @forms == 0; # what should this mean?
    return $forms[2] if @forms &gt; 2 and $num == 0; # special zeroth case

    # Normal case:
    # Note that the formatting of $num is preserved.
    return( $handle-&gt;numf($num) . &#039; &#039; . $handle-&gt;numerate($num, @forms) );
    # Most human languages put the number phrase before the qualified phrase.
}


sub numerate {
    # return this lexical item in a form appropriate to this number
    my($handle, $num, @forms) = @_;
    my $s = ($num == 1);

    return &#039;&#039; unless @forms;
    if(@forms == 1) { # only the headword form specified
        return $s ? $forms[0] : ($forms[0] . &#039;s&#039;); # very cheap hack.
    }
    else { # sing and plural were specified
        return $s ? $forms[0] : $forms[1];
    }
}

#--------------------------------------------------------------------------

sub numf {
    my($handle, $num) = @_[0,1];
    if($num &lt; 10_000_000_000 and $num &gt; -10_000_000_000 and $num == int($num)) {
        $num += 0;  # Just use normal integer stringification.
        # Specifically, don&#039;t let %G turn ten million into 1E+007
    }
    else {
        $num = CORE::sprintf(&#039;%G&#039;, $num);
        # &quot;CORE::&quot; is there to avoid confusion with the above sub sprintf.
    }
    while( $num =~ s/^([-+]?\d+)(\d{3})/$1,$2/s ) {1}  # right from perlfaq5
    # The initial \d+ gobbles as many digits as it can, and then we
    #  backtrack so it un-eats the rightmost three, and then we
    #  insert the comma there.

    $num =~ tr&lt;.,&gt;&lt;,.&gt; if ref($handle) and $handle-&gt;{&#039;numf_comma&#039;};
    # This is just a lame hack instead of using Number::Format
    return $num;
}

sub sprintf {
    no integer;
    my($handle, $format, @params) = @_;
    return CORE::sprintf($format, @params);
    # &quot;CORE::&quot; is there to avoid confusion with myself!
}

#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#

use integer; # vroom vroom... applies to the whole rest of the module

sub language_tag {
    my $it = ref($_[0]) || $_[0];
    return undef unless $it =~ m/([^&#039;:]+)(?:::)?$/s;
    $it = lc($1);
    $it =~ tr&lt;_&gt;&lt;-&gt;;
    return $it;
}

sub encoding {
    my $it = $_[0];
    return(
        (ref($it) &amp;&amp; $it-&gt;{&#039;encoding&#039;})
        || &#039;iso-8859-1&#039;   # Latin-1
    );
}

#--------------------------------------------------------------------------

sub fallback_languages { return(&#039;i-default&#039;, &#039;en&#039;, &#039;en-US&#039;) }

sub fallback_language_classes { return () }

#--------------------------------------------------------------------------

sub fail_with { # an actual attribute method!
    my($handle, @params) = @_;
    return unless ref($handle);
    $handle-&gt;{&#039;fail&#039;} = $params[0] if @params;
    return $handle-&gt;{&#039;fail&#039;};
}

#--------------------------------------------------------------------------

sub blacklist {
    my ( $handle, @methods ) = @_;

    unless ( defined $handle-&gt;{&#039;blacklist&#039;} ) {
        no strict &#039;refs&#039;;

        # Don&#039;t let people call methods they&#039;re not supposed to from maketext.
        # Explicitly exclude all methods in this package that start with an
        # underscore on principle.
        $handle-&gt;{&#039;blacklist&#039;} = {
            map { $_ =&gt; 1 } (
                qw/
                  blacklist
                  encoding
                  fail_with
                  failure_handler_auto
                  fallback_language_classes
                  fallback_languages
                  get_handle
                  init
                  language_tag
                  maketext
                  new
                  whitelist
                  /, grep { /^_/ } keys %{ __PACKAGE__ . &quot;::&quot; }
            ),
        };
    }

    if ( scalar @methods ) {
        $handle-&gt;{&#039;blacklist&#039;} = { %{ $handle-&gt;{&#039;blacklist&#039;} }, map { $_ =&gt; 1 } @methods };
    }

    delete $handle-&gt;{&#039;_external_lex_cache&#039;};
    return;
}

sub whitelist {
    my ( $handle, @methods ) = @_;
    if ( scalar @methods ) {
        $handle-&gt;{&#039;whitelist&#039;} = {} unless defined $handle-&gt;{&#039;whitelist&#039;};
        $handle-&gt;{&#039;whitelist&#039;} = { %{ $handle-&gt;{&#039;whitelist&#039;} }, map { $_ =&gt; 1 } @methods };
    }

    delete $handle-&gt;{&#039;_external_lex_cache&#039;};
    return;
}

#--------------------------------------------------------------------------

sub failure_handler_auto {
    # Meant to be used like:
    #  $handle-&gt;fail_with(&#039;failure_handler_auto&#039;)

    my $handle = shift;
    my $phrase = shift;

    $handle-&gt;{&#039;failure_lex&#039;} ||= {};
    my $lex = $handle-&gt;{&#039;failure_lex&#039;};

    my $value ||= ($lex-&gt;{$phrase} ||= $handle-&gt;_compile($phrase));

    # Dumbly copied from sub maketext:
    return ${$value} if ref($value) eq &#039;SCALAR&#039;;
    return $value    if ref($value) ne &#039;CODE&#039;;
    {
        local $SIG{&#039;__DIE__&#039;};
        eval { $value = &amp;$value($handle, @_) };
    }
    # If we make it here, there was an exception thrown in the
    #  call to $value, and so scream:
    if($@) {
        # pretty up the error message
        $@ =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
                 {\n in bracket code [compiled line $1],}s;
        #$err =~ s/\n?$/\n/s;
        Carp::croak &quot;Error in maketexting \&quot;$phrase\&quot;:\n$@ as used&quot;;
        # Rather unexpected, but suppose that the sub tried calling
        # a method that didn&#039;t exist.
    }
    else {
        return $value;
    }
}

#==========================================================================

sub new {
    # Nothing fancy!
    my $class = ref($_[0]) || $_[0];
    my $handle = bless {}, $class;
    $handle-&gt;blacklist;
    $handle-&gt;init;
    return $handle;
}

sub init { return } # no-op

###########################################################################

sub maketext {
    # Remember, this can fail.  Failure is controllable many ways.
    Carp::croak &#039;maketext requires at least one parameter&#039; unless @_ &gt; 1;

    my($handle, $phrase) = splice(@_,0,2);
    Carp::confess(&#039;No handle/phrase&#039;) unless (defined($handle) &amp;&amp; defined($phrase));

    # backup $@ in case it&#039;s still being used in the calling code.
    # If no failures, we&#039;ll re-set it back to what it was later.
    my $at = $@;

    # Copy @_ case one of its elements is $@.
    @_ = @_;

    # Look up the value:

    my $value;
    if (exists $handle-&gt;{&#039;_external_lex_cache&#039;}{$phrase}) {
        DEBUG and warn &quot;* Using external lex cache version of \&quot;$phrase\&quot;\n&quot;;
        $value = $handle-&gt;{&#039;_external_lex_cache&#039;}{$phrase};
    }
    else {
        foreach my $h_r (
            @{  $isa_scan{ref($handle) || $handle} || $handle-&gt;_lex_refs  }
        ) {
            DEBUG and warn &quot;* Looking up \&quot;$phrase\&quot; in $h_r\n&quot;;
            if(exists $h_r-&gt;{$phrase}) {
                DEBUG and warn &quot;  Found \&quot;$phrase\&quot; in $h_r\n&quot;;
                unless(ref($value = $h_r-&gt;{$phrase})) {
                    # Nonref means it&#039;s not yet compiled.  Compile and replace.
                    if ($handle-&gt;{&#039;use_external_lex_cache&#039;}) {
                        $value = $handle-&gt;{&#039;_external_lex_cache&#039;}{$phrase} = $handle-&gt;_compile($value);
                    }
                    else {
                        $value = $h_r-&gt;{$phrase} = $handle-&gt;_compile($value);
                    }
                }
                last;
            }
            # extending packages need to be able to localize _AUTO and if readonly can&#039;t &quot;local $h_r-&gt;{&#039;_AUTO&#039;} = 1;&quot;
            # but they can &quot;local $handle-&gt;{&#039;_external_lex_cache&#039;}{&#039;_AUTO&#039;} = 1;&quot;
            elsif($phrase !~ m/^_/s and ($handle-&gt;{&#039;use_external_lex_cache&#039;} ? ( exists $handle-&gt;{&#039;_external_lex_cache&#039;}{&#039;_AUTO&#039;} ? $handle-&gt;{&#039;_external_lex_cache&#039;}{&#039;_AUTO&#039;} : $h_r-&gt;{&#039;_AUTO&#039;} ) : $h_r-&gt;{&#039;_AUTO&#039;})) {
                # it&#039;s an auto lex, and this is an autoable key!
                DEBUG and warn &quot;  Automaking \&quot;$phrase\&quot; into $h_r\n&quot;;
                if ($handle-&gt;{&#039;use_external_lex_cache&#039;}) {
                    $value = $handle-&gt;{&#039;_external_lex_cache&#039;}{$phrase} = $handle-&gt;_compile($phrase);
                }
                else {
                    $value = $h_r-&gt;{$phrase} = $handle-&gt;_compile($phrase);
                }
                last;
            }
            DEBUG&gt;1 and print &quot;  Not found in $h_r, nor automakable\n&quot;;
            # else keep looking
        }
    }

    unless(defined($value)) {
        DEBUG and warn &quot;! Lookup of \&quot;$phrase\&quot; in/under &quot;, ref($handle) || $handle, &quot; fails.\n&quot;;
        if(ref($handle) and $handle-&gt;{&#039;fail&#039;}) {
            DEBUG and warn &quot;WARNING0: maketext fails looking for &lt;$phrase&gt;\n&quot;;
            my $fail;
            if(ref($fail = $handle-&gt;{&#039;fail&#039;}) eq &#039;CODE&#039;) { # it&#039;s a sub reference
                $@ = $at; # Put $@ back in case we altered it along the way.
                return &amp;{$fail}($handle, $phrase, @_);
                # If it ever returns, it should return a good value.
            }
            else { # It&#039;s a method name
                $@ = $at; # Put $@ back in case we altered it along the way.
                return $handle-&gt;$fail($phrase, @_);
                # If it ever returns, it should return a good value.
            }
        }
        else {
            # All we know how to do is this;
            Carp::croak(&quot;maketext doesn&#039;t know how to say:\n$phrase\nas needed&quot;);
        }
    }

    if(ref($value) eq &#039;SCALAR&#039;){
        $@ = $at; # Put $@ back in case we altered it along the way.
        return $$value ;
    }
    if(ref($value) ne &#039;CODE&#039;){
        $@ = $at; # Put $@ back in case we altered it along the way.
        return $value ;
    }

    {
        local $SIG{&#039;__DIE__&#039;};
        eval { $value = &amp;$value($handle, @_) };
    }
    # If we make it here, there was an exception thrown in the
    #  call to $value, and so scream:
    if ($@) {
        # pretty up the error message
        $@ =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
                 {\n in bracket code [compiled line $1],}s;
        #$err =~ s/\n?$/\n/s;
        Carp::croak &quot;Error in maketexting \&quot;$phrase\&quot;:\n$@ as used&quot;;
        # Rather unexpected, but suppose that the sub tried calling
        # a method that didn&#039;t exist.
    }
    else {
        $@ = $at; # Put $@ back in case we altered it along the way.
        return $value;
    }
    $@ = $at; # Put $@ back in case we altered it along the way.
}

###########################################################################

sub get_handle {  # This is a constructor and, yes, it CAN FAIL.
    # Its class argument has to be the base class for the current
    # application&#039;s l10n files.

    my($base_class, @languages) = @_;
    $base_class = ref($base_class) || $base_class;
    # Complain if they use __PACKAGE__ as a project base class?

    if( @languages ) {
        DEBUG and warn &#039;Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
        if($USING_LANGUAGE_TAGS) {   # An explicit language-list was given!
            @languages =
            map {; $_, I18N::LangTags::alternate_language_tags($_) }
            # Catch alternation
            map I18N::LangTags::locale2language_tag($_),
            # If it&#039;s a lg tag, fine, pass thru (untainted)
            # If it&#039;s a locale ID, try converting to a lg tag (untainted),
            # otherwise nix it.
            @languages;
            DEBUG and warn &#039;Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
        }
    }
    else {
        @languages = $base_class-&gt;_ambient_langprefs;
    }

    @languages = $base_class-&gt;_langtag_munging(@languages);

    my %seen;
    foreach my $module_name ( map { $base_class . &#039;::&#039; . $_ }  @languages ) {
        next unless length $module_name; # sanity
        next if $seen{$module_name}++        # Already been here, and it was no-go
        || !&amp;_try_use($module_name); # Try to use() it, but can&#039;t it.
        return($module_name-&gt;new); # Make it!
    }

    return undef; # Fail!
}

###########################################################################

sub _langtag_munging {
    my($base_class, @languages) = @_;

    # We have all these DEBUG statements because otherwise it&#039;s hard as hell
    # to diagnose if/when something goes wrong.

    DEBUG and warn &#039;Lgs1: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

    if($USING_LANGUAGE_TAGS) {
        DEBUG and warn &#039;Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
        @languages     = $base_class-&gt;_add_supers( @languages );

        push @languages, I18N::LangTags::panic_languages(@languages);
        DEBUG and warn &quot;After adding panic languages:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

        push @languages, $base_class-&gt;fallback_languages;
        # You are free to override fallback_languages to return empty-list!
        DEBUG and warn &#039;Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

        @languages =  # final bit of processing to turn them into classname things
        map {
            my $it = $_;  # copy
            $it =~ tr&lt;-A-Z&gt;&lt;_a-z&gt;; # lc, and turn - to _
            $it =~ tr&lt;_a-z0-9&gt;&lt;&gt;cd;  # remove all but a-z0-9_
            $it;
        } @languages
        ;
        DEBUG and warn &quot;Nearing end of munging:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
    }
    else {
        DEBUG and warn &quot;Bypassing language-tags.\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
    }

    DEBUG and warn &quot;Before adding fallback classes:\n&quot;,
    &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

    push @languages, $base_class-&gt;fallback_language_classes;
    # You are free to override that to return whatever.

    DEBUG and warn &quot;Finally:\n&quot;,
    &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

    return @languages;
}

###########################################################################

sub _ambient_langprefs {
    return  I18N::LangTags::Detect::detect();
}

###########################################################################

sub _add_supers {
    my($base_class, @languages) = @_;

    if (!$MATCH_SUPERS) {
        # Nothing
        DEBUG and warn &quot;Bypassing any super-matching.\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

    }
    elsif( $MATCH_SUPERS_TIGHTLY ) {
        DEBUG and warn &quot;Before adding new supers tightly:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
        @languages = I18N::LangTags::implicate_supers( @languages );
        DEBUG and warn &quot;After adding new supers tightly:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;

    }
    else {
        DEBUG and warn &quot;Before adding supers to end:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
        @languages = I18N::LangTags::implicate_supers_strictly( @languages );
        DEBUG and warn &quot;After adding supers to end:\n&quot;,
        &#039; Lgs@&#039;, __LINE__, &#039;: &#039;, map(&quot;&lt;$_&gt;&quot;, @languages), &quot;\n&quot;;
    }

    return @languages;
}

###########################################################################
#
# This is where most people should stop reading.
#
###########################################################################

my %tried = ();
# memoization of whether we&#039;ve used this module, or found it unusable.

sub _try_use {   # Basically a wrapper around &quot;require Modulename&quot;
    # &quot;Many men have tried...&quot;  &quot;They tried and failed?&quot;  &quot;They tried and died.&quot;
    return $tried{$_[0]} if exists $tried{$_[0]};  # memoization

    my $module = $_[0];   # ASSUME sane module name!
    { no strict &#039;refs&#039;;
        no warnings &#039;once&#039;;
        return($tried{$module} = 1)
        if %{$module . &#039;::Lexicon&#039;} or @{$module . &#039;::ISA&#039;};
        # weird case: we never use&#039;d it, but there it is!
    }

    DEBUG and warn &quot; About to use $module ...\n&quot;;

    local $SIG{&#039;__DIE__&#039;};
    local $@;
    local @INC = @INC;
    pop @INC if $INC[-1] eq &#039;.&#039;;
    eval &quot;require $module&quot;; # used to be &quot;use $module&quot;, but no point in that.

    if($@) {
        DEBUG and warn &quot;Error using $module \: $@\n&quot;;
        return $tried{$module} = 0;
    }
    else {
        DEBUG and warn &quot; OK, $module is used\n&quot;;
        return $tried{$module} = 1;
    }
}

#--------------------------------------------------------------------------

sub _lex_refs {  # report the lexicon references for this handle&#039;s class
    # returns an arrayREF!
    no strict &#039;refs&#039;;
    no warnings &#039;once&#039;;
    my $class = ref($_[0]) || $_[0];
    DEBUG and warn &quot;Lex refs lookup on $class\n&quot;;
    return $isa_scan{$class} if exists $isa_scan{$class};  # memoization!

    my @lex_refs;
    my $seen_r = ref($_[1]) ? $_[1] : {};

    if( defined( *{$class . &#039;::Lexicon&#039;}{&#039;HASH&#039;} )) {
        push @lex_refs, *{$class . &#039;::Lexicon&#039;}{&#039;HASH&#039;};
        DEBUG and warn &#039;%&#039; . $class . &#039;::Lexicon contains &#039;,
            scalar(keys %{$class . &#039;::Lexicon&#039;}), &quot; entries\n&quot;;
    }

    # Implements depth(height?)-first recursive searching of superclasses.
    # In hindsight, I suppose I could have just used Class::ISA!
    foreach my $superclass (@{$class . &#039;::ISA&#039;}) {
        DEBUG and warn &quot; Super-class search into $superclass\n&quot;;
        next if $seen_r-&gt;{$superclass}++;
        push @lex_refs, @{&amp;_lex_refs($superclass, $seen_r)};  # call myself
    }

    $isa_scan{$class} = \@lex_refs; # save for next time
    return \@lex_refs;
}

sub clear_isa_scan { %isa_scan = (); return; } # end on a note of simplicity!

#--------------------------------------------------------------------------

sub _compile {
    # This big scary routine compiles an entry.
    # It returns either a coderef if there&#039;s brackety bits in this, or
    #  otherwise a ref to a scalar.

    my $string_to_compile = $_[1]; # There are taint issues using regex on @_ - perlbug 60378,27344

    # The while() regex is more expensive than this check on strings that don&#039;t need a compile.
    # this op causes a ~2% speed hit for strings that need compile and a 250% speed improvement
    # on strings that don&#039;t need compiling.
    return \&quot;$string_to_compile&quot; if($string_to_compile !~ m/[\[~\]]/ms); # return a string ref if chars [~] are not in the string

    my $handle = $_[0];

    my(@code);
    my(@c) = (&#039;&#039;); # &quot;chunks&quot; -- scratch.
    my $call_count = 0;
    my $big_pile = &#039;&#039;;
    {
        my $in_group = 0; # start out outside a group
        my($m, @params); # scratch

        while($string_to_compile =~  # Iterate over chunks.
            m/(
                [^\~\[\]]+  # non-~[] stuff (Capture everything else here)
                |
                ~.       # ~[, ~], ~~, ~other
                |
                \[          # [ presumably opening a group
                |
                \]          # ] presumably closing a group
                |
                ~           # terminal ~ ?
                |
                $
            )/xgs
        ) {
            DEBUG&gt;2 and warn qq{  &quot;$1&quot;\n};

            if($1 eq &#039;[&#039; or $1 eq &#039;&#039;) {       # &quot;[&quot; or end
                # Whether this is &quot;[&quot; or end, force processing of any
                #  preceding literal.
                if($in_group) {
                    if($1 eq &#039;&#039;) {
                        $handle-&gt;_die_pointing($string_to_compile, &#039;Unterminated bracket group&#039;);
                    }
                    else {
                        $handle-&gt;_die_pointing($string_to_compile, &#039;You can\&#039;t nest bracket groups&#039;);
                    }
                }
                else {
                    if ($1 eq &#039;&#039;) {
                        DEBUG&gt;2 and warn &quot;   [end-string]\n&quot;;
                    }
                    else {
                        $in_group = 1;
                    }
                    die &quot;How come \@c is empty?? in &lt;$string_to_compile&gt;&quot; unless @c; # sanity
                    if(length $c[-1]) {
                        # Now actually processing the preceding literal
                        $big_pile .= $c[-1];
                        if($USE_LITERALS and (
                                (ord(&#039;A&#039;) == 65)
                                ? $c[-1] !~ m/[^\x20-\x7E]/s
                                # ASCII very safe chars
                                : $c[-1] !~ m/[^ !&quot;\#\$%&amp;&#039;()*+,\-.\/0-9:;&lt;=&gt;?\@A-Z[\\\]^_`a-z{|}~\x07]/s
                                # EBCDIC very safe chars
                            )) {
                            # normal case -- all very safe chars
                            $c[-1] =~ s/&#039;/\\&#039;/g;
                            push @code, q{ &#039;} . $c[-1] . &quot;&#039;,\n&quot;;
                            $c[-1] = &#039;&#039;; # reuse this slot
                        }
                        else {
                            $c[-1] =~ s/\\\\/\\/g;
                            push @code, &#039; $c[&#039; . $#c . &quot;],\n&quot;;
                            push @c, &#039;&#039;; # new chunk
                        }
                    }
                    # else just ignore the empty string.
                }

            }
            elsif($1 eq &#039;]&#039;) {  # &quot;]&quot;
                # close group -- go back in-band
                if($in_group) {
                    $in_group = 0;

                    DEBUG&gt;2 and warn &quot;   --Closing group [$c[-1]]\n&quot;;

                    # And now process the group...

                    if(!length($c[-1]) or $c[-1] =~ m/^\s+$/s) {
                        DEBUG&gt;2 and warn &quot;   -- (Ignoring)\n&quot;;
                        $c[-1] = &#039;&#039;; # reset out chink
                        next;
                    }

                    #$c[-1] =~ s/^\s+//s;
                    #$c[-1] =~ s/\s+$//s;
                    ($m,@params) = split(/,/, $c[-1], -1);  # was /\s*,\s*/

                    # A bit of a hack -- we&#039;ve turned &quot;~,&quot;&#039;s into DELs, so turn
                    #  &#039;em into real commas here.
                    if (ord(&#039;A&#039;) == 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 &#039;_*&#039; or $m =~ m/^_(-?\d+)$/s) {
                        # Treat [_1,...] as [,_1,...], etc.
                        unshift @params, $m;
                        $m = &#039;&#039;;
                    }
                    elsif($m eq &#039;*&#039;) {
                        $m = &#039;quant&#039;; # &quot;*&quot; for &quot;times&quot;: &quot;4 cars&quot; is 4 times &quot;cars&quot;
                    }
                    elsif($m eq &#039;#&#039;) {
                        $m = &#039;numf&#039;;  # &quot;#&quot; for &quot;number&quot;: [#,_1] for &quot;the number _1&quot;
                    }

                    # Most common case: a simple, legal-looking method name
                    if($m eq &#039;&#039;) {
                        # 0-length method name means to just interpolate:
                        push @code, &#039; (&#039;;
                    }
                    elsif($m =~ /^\w+$/s
                        &amp;&amp; !$handle-&gt;{&#039;blacklist&#039;}{$m}
                        &amp;&amp; ( !defined $handle-&gt;{&#039;whitelist&#039;} || $handle-&gt;{&#039;whitelist&#039;}{$m} )
                        # exclude anything fancy and restrict to the whitelist/blacklist.
                    ) {
                        push @code, &#039; $_[0]-&gt;&#039; . $m . &#039;(&#039;;
                    }
                    else {
                        # TODO: implement something?  or just too icky to consider?
                        $handle-&gt;_die_pointing(
                            $string_to_compile,
                            &quot;Can&#039;t use \&quot;$m\&quot; as a method name in bracket group&quot;,
                            2 + length($c[-1])
                        );
                    }

                    pop @c; # we don&#039;t need that chunk anymore
                    ++$call_count;

                    foreach my $p (@params) {
                        if($p eq &#039;_*&#039;) {
                            # Meaning: all parameters except $_[0]
                            $code[-1] .= &#039; @_[1 .. $#_], &#039;;
                            # and yes, that does the right thing for all @_ &lt; 3
                        }
                        elsif($p =~ m/^_(-?\d+)$/s) {
                            # _3 meaning $_[3]
                            $code[-1] .= &#039;$_[&#039; . (0 + $1) . &#039;], &#039;;
                        }
                        elsif($USE_LITERALS and (
                                (ord(&#039;A&#039;) == 65)
                                ? $p !~ m/[^\x20-\x7E]/s
                                # ASCII very safe chars
                                : $p !~ m/[^ !&quot;\#\$%&amp;&#039;()*+,\-.\/0-9:;&lt;=&gt;?\@A-Z[\\\]^_`a-z{|}~\x07]/s
                                # EBCDIC very safe chars
                            )) {
                            # Normal case: a literal containing only safe characters
                            $p =~ s/&#039;/\\&#039;/g;
                            $code[-1] .= q{&#039;} . $p . q{&#039;, };
                        }
                        else {
                            # Stow it on the chunk-stack, and just refer to that.
                            push @c, $p;
                            push @code, &#039; $c[&#039; . $#c . &#039;], &#039;;
                        }
                    }
                    $code[-1] .= &quot;),\n&quot;;

                    push @c, &#039;&#039;;
                }
                else {
                    $handle-&gt;_die_pointing($string_to_compile, q{Unbalanced &#039;]&#039;});
                }

            }
            elsif(substr($1,0,1) ne &#039;~&#039;) {
                # it&#039;s stuff not containing &quot;~&quot; or &quot;[&quot; or &quot;]&quot;
                # i.e., a literal blob
                my $text = $1;
                $text =~ s/\\/\\\\/g;
                $c[-1] .= $text;

            }
            elsif($1 eq &#039;~~&#039;) { # &quot;~~&quot;
                $c[-1] .= &#039;~&#039;;

            }
            elsif($1 eq &#039;~[&#039;) { # &quot;~[&quot;
                $c[-1] .= &#039;[&#039;;

            }
            elsif($1 eq &#039;~]&#039;) { # &quot;~]&quot;
                $c[-1] .= &#039;]&#039;;

            }
            elsif($1 eq &#039;~,&#039;) { # &quot;~,&quot;
                if($in_group) {
                    # This is a hack, based on the assumption that no-one will actually
                    # want a DEL inside a bracket group.  Let&#039;s hope that&#039;s it&#039;s true.
                    if (ord(&#039;A&#039;) == 65) { # ASCII etc
                        $c[-1] .= &quot;\x7F&quot;;
                    }
                    else {              # EBCDIC (cp 1047, 0037, POSIX-BC)
                        $c[-1] .= &quot;\x07&quot;;
                    }
                }
                else {
                    $c[-1] .= &#039;~,&#039;;
                }

            }
            elsif($1 eq &#039;~&#039;) { # possible only at string-end, it seems.
                $c[-1] .= &#039;~&#039;;

            }
            else {
                # It&#039;s a &quot;~X&quot; where X is not a special character.
                # Consider it a literal ~ and X.
                my $text = $1;
                $text =~ s/\\/\\\\/g;
                $c[-1] .= $text;
            }
        }
    }

    if($call_count) {
        undef $big_pile; # Well, nevermind that.
    }
    else {
        # It&#039;s all literals!  Ahwell, that can happen.
        # So don&#039;t bother with the eval.  Return a SCALAR reference.
        return \$big_pile;
    }

    die q{Last chunk isn&#039;t null??} if @c and length $c[-1]; # sanity
    DEBUG and warn scalar(@c), &quot; chunks under closure\n&quot;;
    if(@code == 0) { # not possible?
        DEBUG and warn &quot;Empty code\n&quot;;
        return \&#039;&#039;;
    }
    elsif(@code &gt; 1) { # most cases, presumably!
        unshift @code, &quot;join &#039;&#039;,\n&quot;;
    }
    unshift @code, &quot;use strict; sub {\n&quot;;
    push @code, &quot;}\n&quot;;

    DEBUG and warn @code;
    my $sub = eval(join &#039;&#039;, @code);
    die &quot;$@ while evalling&quot; . join(&#039;&#039;, @code) if $@; # Should be impossible.
    return $sub;
}

#--------------------------------------------------------------------------

sub _die_pointing {
    # This is used by _compile to throw a fatal error
    my $target = shift;
    $target = ref($target) || $target; # class name
                                       # ...leaving $_[0] the error-causing text, and $_[1] the error message

    my $i = index($_[0], &quot;\n&quot;);

    my $pointy;
    my $pos = pos($_[0]) - (defined($_[2]) ? $_[2] : 0) - 1;
    if($pos &lt; 1) {
        $pointy = &quot;^=== near there\n&quot;;
    }
    else { # we need to space over
        my $first_tab = index($_[0], &quot;\t&quot;);
        if($pos &gt; 2 and ( -1 == $first_tab  or  $first_tab &gt; pos($_[0]))) {
            # No tabs, or the first tab is harmlessly after where we will point to,
            # AND we&#039;re far enough from the margin that we can draw a proper arrow.
            $pointy = (&#039;=&#039; x $pos) . &quot;^ near there\n&quot;;
        }
        else {
            # tabs screw everything up!
            $pointy = substr($_[0],0,$pos);
            $pointy =~ tr/\t //cd;
            # make everything into whitespace, but preserving tabs
            $pointy .= &quot;^=== near there\n&quot;;
        }
    }

    my $errmsg = &quot;$_[1], in\:\n$_[0]&quot;;

    if($i == -1) {
        # No newline.
        $errmsg .= &quot;\n&quot; . $pointy;
    }
    elsif($i == (length($_[0]) - 1)  ) {
        # Already has a newline at end.
        $errmsg .= $pointy;
    }
    else {
        # don&#039;t bother with the pointy bit, I guess.
    }
    Carp::croak( &quot;$errmsg via $target, as used&quot; );
}

1;
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/perl5/vendor_perl/Locale/Maketext.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FLocale' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>