

<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: Codes.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::Codes;
# Copyright (C) 2001      Canon Research Centre Europe (CRE).
# Copyright (C) 2002-2009 Neil Bowers
# Copyright (c) 2010-2018 Sullivan Beck
# This program is free software; you can redistribute it and/or modify it
# under the same terms as Perl itself.

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

use strict;
use warnings;
require 5.006;

use Carp;
use if $] &gt;= 5.027007, &#039;deprecate&#039;;
use Locale::Codes::Constants;

our($VERSION);
$VERSION=&#039;3.57&#039;;

use Exporter qw(import);
our(@EXPORT_OK,%EXPORT_TAGS);
@EXPORT_OK   = @Locale::Codes::Constants::CONSTANTS;
%EXPORT_TAGS = ( &#039;constants&#039; =&gt; [ @EXPORT_OK ] );

###############################################################################
# GLOBAL DATA
###############################################################################
# All of the data is stored in a couple global variables.  They are filled
# in by requiring the appropriate TYPE_Codes and TYPE_Retired modules.

our(%Data,%Retired);

# $Data{ TYPE }{ code2id   }{ CODESET } { CODE }  = [ ID, I ]
#              { id2code   }{ CODESET } { ID }    = CODE
#              { id2names  }{ ID }                = [ NAME, NAME, ... ]
#              { alias2id  }{ NAME }              = [ ID, I ]
#              { id        }                      = FIRST_UNUSED_ID
#              { codealias }{ CODESET } { ALIAS } = CODE
#
# $Retired{ TYPE }{ CODESET }{ code }{ CODE } = NAME
#                            { name }{ NAME } = [CODE,NAME]  (the key is lowercase)

###############################################################################
# METHODS
###############################################################################

sub new {
   my($class,$type,$codeset,$show_errors) = @_;
   my $self         = { &#039;type&#039;     =&gt; &#039;&#039;,
                        &#039;codeset&#039;  =&gt; &#039;&#039;,
                        &#039;err&#039;      =&gt; (defined($show_errors) ? $show_errors : 1),
                      };

   bless $self,$class;

   $self-&gt;type($type)        if ($type);
   $self-&gt;codeset($codeset)  if ($codeset);
   return $self;
}

sub show_errors {
   my($self,$val) = @_;
   $$self{&#039;err&#039;}  = $val;
}

sub type {
   my($self,$type) = @_;

   if (! exists $ALL_CODESETS{$type}) {
      # uncoverable branch false
      carp &quot;ERROR: type: invalid argument: $type\n&quot;  if ($$self{&#039;err&#039;});
      return;
   }

   # uncoverable branch false
   if (! $ALL_CODESETS{$type}{&#039;loaded&#039;}) {
      my $label = $ALL_CODESETS{$type}{&#039;module&#039;};
      eval &quot;require Locale::Codes::${label}_Codes&quot;;
      # uncoverable branch true
      if ($@) {
         # uncoverable statement
         croak &quot;ERROR: type: unable to load module: ${label}_Codes\n&quot;;
      }
      eval &quot;require Locale::Codes::${label}_Retired&quot;;
      # uncoverable branch true
      if ($@) {
         # uncoverable statement
         croak &quot;ERROR: type: unable to load module: ${label}_Retired\n&quot;;
      }
      $ALL_CODESETS{$type}{&#039;loaded&#039;} = 1;
   }

   $$self{&#039;type&#039;}    = $type;
   $$self{&#039;codeset&#039;} = $ALL_CODESETS{$type}{&#039;default&#039;};
}

sub codeset {
   my($self,$codeset) = @_;

   my $type           = $$self{&#039;type&#039;};
   if (! exists $ALL_CODESETS{$type}{&#039;codesets&#039;}{$codeset}) {
      # uncoverable branch false
      carp &quot;ERROR: codeset: invalid argument: $codeset\n&quot;  if ($$self{&#039;err&#039;});
   }

   $$self{&#039;codeset&#039;}  = $codeset;
}

sub version {
  # uncoverable subroutine
  # uncoverable statement
  my($self) = @_;
  # uncoverable statement
  return $VERSION;
}

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

# This is used to validate a codeset and/or code.  It will also format
# a code for that codeset.
#
# (ERR,RET_CODE,RET_CODESET) = $o-&gt;_code([CODE [,CODESET]])
#
#    If CODE is empty/undef, only the codeset will be validated
#    and RET_CODE will be empty.
#
#    If CODE is passed in, it will be returned formatted correctly
#    for the codeset.
#
#    ERR will be 0 or 1.
#
#    If $no_check_code is 1, then the code will not be validated (i.e.
#    it doesn&#039;t already have to exist).  This will be useful for adding
#    a new code.
#
sub _code {
   my($self,$code,$codeset,$no_check_code) = @_;
   $code                    = &#039;&#039;  if (! defined($code));
   $codeset                 = lc($codeset)  if (defined($codeset));

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};
   if ($codeset  &amp;&amp;  ! exists $ALL_CODESETS{$type}{&#039;codesets&#039;}{$codeset}) {
      carp &quot;ERROR: _code: invalid codeset provided: $codeset\n&quot;
        if ($$self{&#039;err&#039;});
      return (1);
   }

   # If no codeset was passed in, return the codeset specified.

   $codeset = $$self{&#039;codeset&#039;}  if (! defined($codeset)  ||  $codeset eq &#039;&#039;);
   return (0,&#039;&#039;,$codeset)        if ($code eq &#039;&#039;);

   # Determine the properties of the codeset

   my($op,@args) = @{ $ALL_CODESETS{$type}{&#039;codesets&#039;}{$codeset} };

   if      ($op eq &#039;lc&#039;) {
      $code = lc($code);
   }

   if ($op eq &#039;uc&#039;) {
      $code = uc($code);
   }

   if ($op eq &#039;ucfirst&#039;) {
      $code = ucfirst(lc($code));
   }

   # uncoverable branch false
   if ($op eq &#039;numeric&#039;) {
      if ($code =~ /^\d+$/) {
         my $l = $args[0];
         $code    = sprintf(&quot;%.${l}d&quot;, $code);

      } else {
         # uncoverable statement
         carp &quot;ERROR: _code: invalid numeric code: $code\n&quot;  if ($$self{&#039;err&#039;});
         # uncoverable statement
         return (1);
      }
   }

   # Determine if the code is in the codeset.

   if (! $no_check_code  &amp;&amp;
       ! exists $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}  &amp;&amp;
       ! exists $Retired{$type}{$codeset}{&#039;code&#039;}{$code}  &amp;&amp;
       ! exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$code}) {
      carp &quot;ERROR: _code: code not in codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      return (1);
   }

   return (0,$code,$codeset);
}

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

# $name = $o-&gt;code2name(CODE [,CODESET] [,&#039;retired&#039;])
# $code = $o-&gt;name2code(NAME [,CODESET] [,&#039;retired&#039;])
#
#    Returns the name associated with the CODE (or vice versa).
#
sub code2name {
   my($self,@args)   = @_;
   my $retired       = 0;
   if (@args  &amp;&amp;  defined($args[$#args])  &amp;&amp;  lc($args[$#args]) eq &#039;retired&#039;) {
      pop(@args);
      $retired       = 1;
   }

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};

   my ($err,$code,$codeset) = $self-&gt;_code(@args);
   return undef  if ($err  ||  ! $code);

   $code = $Data{$type}{&#039;codealias&#039;}{$codeset}{$code}
     if (exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$code});

   if (exists $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}) {
      my ($id,$i) = @{ $Data{$type}{&#039;code2id&#039;}{$codeset}{$code} };
      my $name    = $Data{$type}{&#039;id2names&#039;}{$id}[$i];
      return $name;

   } elsif ($retired  &amp;&amp;  exists $Retired{$type}{$codeset}{&#039;code&#039;}{$code}) {
      return $Retired{$type}{$codeset}{&#039;code&#039;}{$code};

   } else {
      return undef;
   }
}

sub name2code {
   my($self,$name,@args)   = @_;
   return undef  if (! $name);
   $name                   = lc($name);

   my $retired       = 0;
   if (@args  &amp;&amp;  defined($args[$#args])  &amp;&amp;  lc($args[$#args]) eq &#039;retired&#039;) {
      pop(@args);
      $retired       = 1;
   }

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};

   my ($err,$tmp,$codeset) = $self-&gt;_code(&#039;&#039;,@args);
   return undef  if ($err);

   if (exists $Data{$type}{&#039;alias2id&#039;}{$name}) {
      my $id = $Data{$type}{&#039;alias2id&#039;}{$name}[0];
      if (exists $Data{$type}{&#039;id2code&#039;}{$codeset}{$id}) {
         return $Data{$type}{&#039;id2code&#039;}{$codeset}{$id};
      }

   } elsif ($retired  &amp;&amp;  exists $Retired{$type}{$codeset}{&#039;name&#039;}{$name}) {
      return $Retired{$type}{$codeset}{&#039;name&#039;}{$name}[0];
   }

   return undef;
}

# $code = $o-&gt;code2code(CODE,CODESET2)
# $code = $o-&gt;code2code(CODE,CODESET1,CODESET2)
#
#    Changes the code in the CODESET1 (or the current codeset) to another
#    codeset (CODESET2)
#
sub code2code {
   my($self,@args) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};

   my($code,$codeset1,$codeset2,$err);

   if (@args == 2) {
      ($code,$codeset2)      = @args;
      ($err,$code,$codeset1) = $self-&gt;_code($code);
      # uncoverable branch true
      return undef  if ($err);

   } elsif (@args == 3) {
      ($code,$codeset1,$codeset2) = @args;
      ($err,$code)                = $self-&gt;_code($code,$codeset1);
      return undef  if ($err);
      ($err)                      = $self-&gt;_code(&#039;&#039;,$codeset2);
      # uncoverable branch true
      return undef  if ($err);
   }

   my $name    = $self-&gt;code2name($code,$codeset1);
   my $out     = $self-&gt;name2code($name,$codeset2);
   return $out;
}

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

# @codes = $o-&gt;all_codes([CODESET] [,&#039;retired&#039;]);
# @names = $o-&gt;all_names([CODESET] [,&#039;retired&#039;]);
#
#    Returns all codes/names in the specified codeset, including retired
#    ones if the option is given.

sub all_codes {
   my($self,@args)   = @_;
   my $retired       = 0;
   if (@args  &amp;&amp;  defined($args[$#args])  &amp;&amp;  lc($args[$#args]) eq &#039;retired&#039;) {
      pop(@args);
      $retired       = 1;
   }

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};

   my ($err,$tmp,$codeset) = $self-&gt;_code(&#039;&#039;,@args);
   return ()  if ($err);

   my @codes = keys %{ $Data{$type}{&#039;code2id&#039;}{$codeset} };
   push(@codes,keys %{ $Retired{$type}{$codeset}{&#039;code&#039;} })  if ($retired);
   return (sort @codes);
}

sub all_names {
   my($self,@args)   = @_;
   my $retired       = 0;
   if (@args  &amp;&amp;  defined($args[$#args])  &amp;&amp;  lc($args[$#args]) eq &#039;retired&#039;) {
      pop(@args);
      $retired       = 1;
   }

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return (1);
   }
   my $type = $$self{&#039;type&#039;};

   my ($err,$tmp,$codeset) = $self-&gt;_code(&#039;&#039;,@args);
   return ()  if ($err);

   my @codes = $self-&gt;all_codes($codeset);
   my @names;

   foreach my $code (@codes) {
      my($id,$i) = @{ $Data{$type}{&#039;code2id&#039;}{$codeset}{$code} };
      my $name   = $Data{$type}{&#039;id2names&#039;}{$id}[$i];
      push(@names,$name);
   }
   if ($retired) {
      foreach my $lc (keys %{ $Retired{$type}{$codeset}{&#039;name&#039;} }) {
         my $name = $Retired{$type}{$codeset}{&#039;name&#039;}{$lc}[1];
         push @names,$name;
      }
   }
   return (sort @names);
}

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

# $flag = $o-&gt;rename_code (CODE,NEW_NAME [,CODESET])
#
# Change the official name for a code. The original is retained
# as an alias, but the new name will be returned if you lookup the
# name from code.
#
# Returns 1 on success.
#
sub rename_code {
   my($self,$code,$new_name,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure $code/$codeset are both valid

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset);
   if ($err) {
      carp &quot;ERROR: rename: Unknown code/codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }
   ($code,$codeset) = ($c,$cs);

   # Cases:
   #   1. Renaming to a name which exists with a different ID
   #      Error
   #
   #   2. Renaming to a name which exists with the same ID
   #      Just change code2id (I value)
   #
   #   3. Renaming to a new name
   #      Create a new alias
   #      Change code2id (I value)

   my $id = $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[0];

   if (exists $Data{$type}{&#039;alias2id&#039;}{lc($new_name)}) {
      # Existing name (case 1 and 2)

      my ($new_id,$i) = @{ $Data{$type}{&#039;alias2id&#039;}{lc($new_name)} };
      if ($new_id != $id) {
         # Case 1
         carp &quot;ERROR: rename: rename to an existing name not allowed\n&quot;
           if ($$self{&#039;err&#039;});
         return 0;
      }

      # Case 2

      $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[1] = $i;

   } else {

      # Case 3

      push @{ $Data{$type}{&#039;id2names&#039;}{$id} },$new_name;
      my $i = $#{ $Data{$type}{&#039;id2names&#039;}{$id} };
      $Data{$type}{&#039;alias2id&#039;}{lc($new_name)} = [ $id,$i ];
      $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[1] = $i;
   }

   return 1;
}

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

# $flag = $o-&gt;add_code (CODE,NAME [,CODESET])
#
# Add a new code to the codeset. Both CODE and NAME must be
# unused in the code set.
#
sub add_code {
   my($self,$code,$name,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure that $codeset is valid.

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset,1);
   if ($err) {
      carp &quot;ERROR: rename: Unknown codeset: $codeset\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }
  ($code,$codeset) = ($c,$cs);

   # Check that $code is unused.

   if (exists $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}  ||
       exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$code}) {
      carp &quot;add_code: code already in use: $code\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   # Check to see that $name is unused in this code set.  If it is
   # used (but not in this code set), we&#039;ll use that ID.  Otherwise,
   # we&#039;ll need to get the next available ID.

   my ($id,$i);
   if (exists $Data{$type}{&#039;alias2id&#039;}{lc($name)}) {
      ($id,$i) = @{ $Data{$type}{&#039;alias2id&#039;}{lc($name)} };
      if (exists $Data{$type}{&#039;id2code&#039;}{$codeset}{$id}) {
         carp &quot;add_code: name already in use: $name\n&quot;  if ($$self{&#039;err&#039;});
         return 0;
      }

   } else {
      $id = $Data{$type}{&#039;id&#039;}++;
      $i  = 0;
      $Data{$type}{&#039;alias2id&#039;}{lc($name)} = [ $id,$i ];
      $Data{$type}{&#039;id2names&#039;}{$id}       = [ $name ];
   }

   # Add the new code

   $Data{$type}{&#039;code2id&#039;}{$codeset}{$code} = [ $id,$i ];
   $Data{$type}{&#039;id2code&#039;}{$codeset}{$id}   = $code;

   return 1;
}

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

# $flag = $o-&gt;delete_code (CODE [,CODESET])
#
# Delete a code from the codeset.
#
sub delete_code {
   my($self,$code,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure $code/$codeset are both valid

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset);
   # uncoverable branch true
   if ($err) {
      # uncoverable statement
      carp &quot;ERROR: rename: Unknown code/codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   ($code,$codeset) = ($c,$cs);

   # Delete the code

   my $id = $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[0];
   delete $Data{$type}{&#039;code2id&#039;}{$codeset}{$code};
   delete $Data{$type}{&#039;id2code&#039;}{$codeset}{$id};

   # Delete any aliases that are linked to this code

   foreach my $alias (keys %{ $Data{$type}{&#039;codealias&#039;}{$codeset} }) {
      next  if ($Data{$type}{&#039;codealias&#039;}{$codeset}{$alias} ne $code);
      delete $Data{$type}{&#039;codealias&#039;}{$codeset}{$alias};
   }

   # If this ID is not used in any other codeset, delete it completely.

   foreach my $c (keys %{ $Data{$type}{&#039;id2code&#039;} }) {
      return 1  if (exists $Data{$type}{&#039;id2code&#039;}{$c}{$id});
   }

   my @names = @{ $Data{$type}{&#039;id2names&#039;}{$id} };
   delete $Data{$type}{&#039;id2names&#039;}{$id};

   foreach my $name (@names) {
      delete $Data{$type}{&#039;alias2id&#039;}{lc($name)};
   }

   return 1;
}

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

# $flag = $o-&gt;add_alias (NAME,NEW_NAME)
#
# Add a new alias. NAME must exist, and NEW_NAME must be unused.
#
sub add_alias {
   my($self,$name,$new_name) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Check that $name is used and $new_name is new.

   my($id);
   if (exists $Data{$type}{&#039;alias2id&#039;}{lc($name)}) {
      $id = $Data{$type}{&#039;alias2id&#039;}{lc($name)}[0];
   } else {
      carp &quot;add_alias: name does not exist: $name\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   if (exists $Data{$type}{&#039;alias2id&#039;}{lc($new_name)}) {
      carp &quot;add_alias: alias already in use: $new_name\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   # Add the new alias

   push @{ $Data{$type}{&#039;id2names&#039;}{$id} },$new_name;
   my $i = $#{ $Data{$type}{&#039;id2names&#039;}{$id} };
   $Data{$type}{&#039;alias2id&#039;}{lc($new_name)} = [ $id,$i ];

   return 1;
}

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

# $flag = $o-&gt;delete_alias (NAME)
#
# This deletes a name from the list of names used by an element.
# NAME must be used, but must NOT be the only name in the list.
#
# Any id2name that references this name will be changed to
# refer to the first name in the list.
#
sub delete_alias {
   my($self,$name) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Check that $name is used.

   my($id,$i);
   if (exists $Data{$type}{&#039;alias2id&#039;}{lc($name)}) {
      ($id,$i) = @{ $Data{$type}{&#039;alias2id&#039;}{lc($name)} };
   } else {
      carp &quot;delete_alias: name does not exist: $name\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   my $n = $#{ $Data{$type}{&#039;id2names&#039;}{$id} } + 1;
   if ($n == 1) {
      carp &quot;delete_alias: only one name defined (use delete_code instead)\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }

   # Delete the alias.

   splice (@{ $Data{$type}{&#039;id2names&#039;}{$id} },$i,1);
   delete $Data{$type}{&#039;alias2id&#039;}{lc($name)};

   # Every element that refers to this ID:
   #   Ignore     if I &lt; $i
   #   Set to 0   if I = $i
   #   Decrement  if I &gt; $i

   foreach my $codeset (keys %{ $Data{$type}{&#039;code2id&#039;} }) {
      foreach my $code (keys %{ $Data{$type}{&#039;code2id&#039;}{$codeset} }) {
         my($jd,$j) = @{ $Data{$type}{&#039;code2id&#039;}{$codeset}{$code} };
         next  if ($jd ne $id  ||
                   $j &lt; $i);
         if ($i == $j) {
            $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[1] = 0;
         } else {
            $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[1]--;
         }
      }
   }

   return 1;
}

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

# $flag = $o-&gt;replace_code (CODE,NEW_CODE [,CODESET])
#
# Change the official code. The original is retained as an alias, but
# the new code will be returned if do a name2code lookup.
#
sub replace_code {
   my($self,$code,$new_code,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure $code/$codeset are both valid (and that $new_code is the
   # correct format)

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset);
   if ($err) {
      carp &quot;ERROR: rename_code: Unknown code/codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }
   ($code,$codeset) = ($c,$cs);

   ($err,$new_code,$codeset) = $self-&gt;_code($new_code,$codeset,1);

   # Cases:
   #   1. Renaming code to an existing alias of this code:
   #      Make the alias real and the code an alias
   #
   #   2. Renaming code to some other existing alias:
   #      Error
   #
   #   3. Renaming code to some other code:
   #      Error (
   #
   #   4. Renaming code to a new code:
   #      Make code into an alias
   #      Replace code with new_code.

   if (exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$new_code}) {
      # Cases 1 and 2
      if ($Data{$type}{&#039;codealias&#039;}{$codeset}{$new_code} eq $code) {
         # Case 1

         delete $Data{$type}{&#039;codealias&#039;}{$codeset}{$new_code};

      } else {
         # Case 2
         carp &quot;rename_code: new code already in use: $new_code\n&quot;
           if ($$self{&#039;err&#039;});
         return 0;
      }

   } elsif (exists $Data{$type}{&#039;code2id&#039;}{$codeset}{$new_code}) {
      # Case 3
      carp &quot;rename_code: new code already in use: $new_code\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }

   # Cases 1 and 4

   $Data{$type}{&#039;codealias&#039;}{$codeset}{$code} = $new_code;

   my $id = $Data{$type}{&#039;code2id&#039;}{$codeset}{$code}[0];
   $Data{$type}{&#039;code2id&#039;}{$codeset}{$new_code} =
     $Data{$type}{&#039;code2id&#039;}{$codeset}{$code};
   delete $Data{$type}{&#039;code2id&#039;}{$codeset}{$code};

   $Data{$type}{&#039;id2code&#039;}{$codeset}{$id} = $new_code;

   return 1;
}

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

# $flag = $o-&gt;add_code_alias (CODE,NEW_CODE [,CODESET])
#
# Adds an alias for the code.
#
sub add_code_alias {
   my($self,$code,$new_code,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure $code/$codeset are both valid and that the new code is
   # properly formatted.

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset);
   if ($err) {
      carp &quot;ERROR: add_code_alias: Unknown code/codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }
   ($code,$codeset) = ($c,$cs);

   ($err,$new_code,$cs) = $self-&gt;_code($new_code,$codeset,1);

   # Check that $new_code does not exist.

   if (exists $Data{$type}{&#039;code2id&#039;}{$codeset}{$new_code}  ||
       exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$new_code}) {
      # uncoverable branch true
      carp &quot;add_code_alias: code already in use: $new_code\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   # Add the alias

   $Data{$type}{&#039;codealias&#039;}{$codeset}{$new_code} = $code;

   return 1;
}

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

# $flag = $o-&gt;delete_code_alias (ALIAS [,CODESET])
#
# Deletes an alias for the code.
#
sub delete_code_alias {
   my($self,$code,$codeset) = @_;

   # uncoverable branch true
   if (! $$self{&#039;type&#039;}) {
      # uncoverable statement
      carp &quot;ERROR: no type set for Locale::Codes object\n&quot;  if ($$self{&#039;err&#039;});
      # uncoverable statement
      return 0;
   }
   my $type = $$self{&#039;type&#039;};

   # Make sure $code/$codeset are both valid

   my($err,$c,$cs) = $self-&gt;_code($code,$codeset);
   if ($err) {
      # uncoverable branch true
      carp &quot;ERROR: rename: Unknown code/codeset: $code [$codeset]\n&quot;
        if ($$self{&#039;err&#039;});
      return 0;
   }
   ($code,$codeset) = ($c,$cs);

   # Check that $code exists in the codeset as an alias.

   if (! exists $Data{$type}{&#039;codealias&#039;}{$codeset}{$code}) {
      # uncoverable branch true
      carp &quot;delete_code_alias(): no alias defined: $code\n&quot;  if ($$self{&#039;err&#039;});
      return 0;
   }

   # Delete the alias

   delete $Data{$type}{&#039;codealias&#039;}{$codeset}{$code};

   return 1;
}

1;
# Local Variables:
# mode: cperl
# indent-tabs-mode: nil
# cperl-indent-level: 3
# cperl-continued-statement-offset: 2
# cperl-continued-brace-offset: 0
# cperl-brace-offset: 0
# cperl-brace-imaginary-offset: 0
# cperl-label-offset: 0
# End:
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/perl5/vendor_perl/Locale/Codes.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>