/*

   Copyright (c) 2000, 2011, Oracle and/or its affiliates

   Copyright (c) 2009, 2020, MariaDB Corporation.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */

#include "mysys_priv.h"

#include "mysys_err.h"

#include <m_ctype.h>

#include <m_string.h>

#include <my_dir.h>

#include <hash.h>

#include <my_xml.h>

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#endif

#ifdef HAVE_LOCALE_H

#include <locale.h>

#endif

extern HASH charset_name_hash;

/*

  The code below implements this functionality:

    - Initializing charset related structures

    - Loading dynamic charsets

    - Searching for a proper CHARSET_INFO 

      using charset name, collation name or collation ID

    - Setting server default character set

*/

static uint

get_collation_number_internal(const char *name)

{

  CHARSET_INFO **cs;

  for (cs= all_charsets;

       cs < all_charsets + array_elements(all_charsets);

       cs++)

  {

    if (cs[0] && cs[0]->coll_name.str &&

        !my_strcasecmp_latin1(cs[0]->coll_name.str, name))

      return cs[0]->number;

  }  

  return 0;

}

static my_bool is_multi_byte_ident(CHARSET_INFO *cs, uchar ch)

{

  int chlen= my_ci_charlen(cs, &ch, &ch + 1);

  return MY_CS_IS_TOOSMALL(chlen) ? TRUE : FALSE;

}

static my_bool init_state_maps(struct charset_info_st *cs)

{

  uint i;

  uchar *state_map;

  uchar *ident_map;

  if (!(cs->state_map= state_map= (uchar*) my_once_alloc(256*2, MYF(MY_WME))))

    return 1;

  cs->ident_map= ident_map= state_map + 256;

  /* Fill state_map with states to get a faster parser */

  for (i=0; i < 256 ; i++)

  {

    if (my_isalpha(cs,i))

      state_map[i]=(uchar) MY_LEX_IDENT;

    else if (my_isdigit(cs,i))

      state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;

    else if (is_multi_byte_ident(cs, i))

      state_map[i]=(uchar) MY_LEX_IDENT;

    else if (my_isspace(cs,i))

      state_map[i]=(uchar) MY_LEX_SKIP;

    else

      state_map[i]=(uchar) MY_LEX_CHAR;

  }

  state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;

  state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;

  state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;

  state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;

  state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;

  state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;

  state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;

  state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;

  state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;

  state_map[0]=(uchar) MY_LEX_EOL;

  state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;

  state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;

  state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;

  state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;

  state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;

  state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;

  state_map[(uchar)'-']= (uchar) MY_LEX_MINUS_OR_COMMENT;

  state_map[(uchar)',']= (uchar) MY_LEX_COMMA;

  state_map[(uchar)'?']= (uchar) MY_LEX_PLACEHOLDER;

  /*

    Create a second map to make it faster to find identifiers

  */

  for (i=0; i < 256 ; i++)

  {

    ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||

         state_map[i] == MY_LEX_NUMBER_IDENT);

  }

  /* Special handling of hex and binary strings */

  state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;

  state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;

  state_map[(uchar)'n']= state_map[(uchar)'N']= (uchar) MY_LEX_IDENT_OR_NCHAR;

  return 0;

}

static MY_COLLATION_HANDLER *get_simple_collation_handler_by_flags(uint flags)

{

  return flags & MY_CS_BINSORT ?

           (flags & MY_CS_NOPAD ?

            &my_collation_8bit_nopad_bin_handler :

            &my_collation_8bit_bin_handler) :

           (flags & MY_CS_NOPAD ?

            &my_collation_8bit_simple_nopad_ci_handler :

            &my_collation_8bit_simple_ci_handler);

}

static void simple_cs_init_functions(struct charset_info_st *cs)

{

  cs->coll= get_simple_collation_handler_by_flags(cs->state);

  cs->cset= &my_charset_8bit_handler;

}

static int cs_copy_data(struct charset_info_st *to, CHARSET_INFO *from)

{

  to->number= from->number ? from->number : to->number;

  /* Don't replace csname if already set */

  if (from->cs_name.str && !to->cs_name.str)

  {

    if (!(to->cs_name.str= my_once_memdup(from->cs_name.str,

                                          from->cs_name.length + 1,

                                          MYF(MY_WME))))

      goto err;

    to->cs_name.length= from->cs_name.length;

  }

  if (from->coll_name.str)

  {

    if (!(to->coll_name.str= my_once_memdup(from->coll_name.str,

                                            from->coll_name.length + 1,

                                            MYF(MY_WME))))

      goto err;

    to->coll_name.length= from->coll_name.length;

  }

  if (from->comment)

    if (!(to->comment= my_once_strdup(from->comment,MYF(MY_WME))))

      goto err;

  if (from->m_ctype)

  {

    if (!(to->m_ctype= (uchar*) my_once_memdup((char*) from->m_ctype,

                                               MY_CS_CTYPE_TABLE_SIZE,

                                               MYF(MY_WME))))

      goto err;

    if (init_state_maps(to))

      goto err;

  }

  if (from->to_lower)

    if (!(to->to_lower= (uchar*) my_once_memdup((char*) from->to_lower,

            MY_CS_TO_LOWER_TABLE_SIZE,

            MYF(MY_WME))))

      goto err;

  if (from->to_upper)

    if (!(to->to_upper= (uchar*) my_once_memdup((char*) from->to_upper,

            MY_CS_TO_UPPER_TABLE_SIZE,

            MYF(MY_WME))))

      goto err;

  if (from->sort_order)

  {

    if (!(to->sort_order= (uchar*) my_once_memdup((char*) from->sort_order,

              MY_CS_SORT_ORDER_TABLE_SIZE,

              MYF(MY_WME))))

      goto err;

  }

  if (from->tab_to_uni)

  {

    uint sz= MY_CS_TO_UNI_TABLE_SIZE*sizeof(uint16);

    if (!(to->tab_to_uni= (uint16*)  my_once_memdup((char*)from->tab_to_uni,

                sz, MYF(MY_WME))))

      goto err;

  }

  if (from->tailoring)

    if (!(to->tailoring= my_once_strdup(from->tailoring,MYF(MY_WME))))

      goto err;

  return 0;

err:

  return 1;

}

static my_bool simple_8bit_charset_data_is_full(CHARSET_INFO *cs)

{

  return cs->m_ctype && cs->to_upper && cs->to_lower && cs->tab_to_uni;

}

/**

  Inherit missing 8bit charset data from another collation.

  Arrays pointed by refcs must be in the permanent memory already,

  e.g. static memory, or allocated by my_once_xxx().

*/

static void

inherit_charset_data(struct charset_info_st *cs, CHARSET_INFO *refcs)

{

  if (!cs->to_upper)

    cs->to_upper= refcs->to_upper;

  if (!cs->to_lower)

    cs->to_lower= refcs->to_lower;

  if (!cs->m_ctype)

    cs->m_ctype= refcs->m_ctype;

  if (!cs->tab_to_uni)

    cs->tab_to_uni= refcs->tab_to_uni;

}

static my_bool simple_8bit_collation_data_is_full(CHARSET_INFO *cs)

{

  return cs->sort_order || (cs->state & MY_CS_BINSORT);

}

/**

  Inherit 8bit simple collation data from another collation.

  refcs->sort_order must be in the permanent memory already,

  e.g. static memory, or allocated by my_once_xxx().

*/

static void

inherit_collation_data(struct charset_info_st *cs, CHARSET_INFO *refcs)

{

  if (!simple_8bit_collation_data_is_full(cs))

    cs->sort_order= refcs->sort_order;

}

static my_bool simple_cs_is_full(CHARSET_INFO *cs)

{

  return  cs->number && cs->cs_name.str && cs->coll_name.str &&

          simple_8bit_charset_data_is_full(cs) &&

          (simple_8bit_collation_data_is_full(cs) || cs->tailoring);

}

#if defined(HAVE_UCA_COLLATIONS) && (defined(HAVE_CHARSET_ucs2) || defined(HAVE_CHARSET_utf8mb3))

/**

  Initialize a loaded collation.

  @param [OUT] to     - The new charset_info_st structure to initialize.

  @param [IN]  from   - A template collation, to fill the missing data from.

  @param [IN]  loaded - The collation data loaded from the LDML file.

                        some data may be missing in "loaded".

*/

static void

copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,

                   CHARSET_INFO *loaded)

{

  to->cset= from->cset;

  to->coll= from->coll;

  /*

    Single-level UCA collation have strnxfrm_multiple=8.

    In case of a multi-level UCA collation we use strnxfrm_multiply=4.

    That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller

    to allocate a buffer smaller size for each level, for performance purpose,

    and to fit longer VARCHARs to @@max_sort_length.

    This makes filesort produce non-precise order for some rare Unicode

    characters that produce more than 4 weights (long expansions).

    UCA requires 2 bytes per weight multiplied by the number of levels.

    In case of a 2-level collation, each character requires 4*2=8 bytes.

    Therefore, the longest VARCHAR that fits into the default @@max_sort_length

    is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)

    would fit.

    Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,

    for the same purpose.

    TODO: we could add a new LDML syntax to choose strxfrm_multiply value.

  */

  to->strxfrm_multiply= loaded->levels_for_order > 1 ?

                        4 : from->strxfrm_multiply;

  to->min_sort_char= from->min_sort_char;

  to->max_sort_char= from->max_sort_char;

  to->mbminlen= from->mbminlen;

  to->mbmaxlen= from->mbmaxlen;

  to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |

              MY_CS_STRNXFRM  | MY_CS_UNICODE;

}

#endif

static int add_collation(struct charset_info_st *cs)

{

  if (cs->coll_name.str &&

      (cs->number ||

       (cs->number=get_collation_number_internal(cs->coll_name.str))) &&

      cs->number < array_elements(all_charsets))

  {

    struct charset_info_st *newcs;

    if (!(newcs= (struct charset_info_st*) all_charsets[cs->number]))

    {

      if (!(all_charsets[cs->number]= newcs=

         (struct charset_info_st*) my_once_alloc(sizeof(CHARSET_INFO),MYF(0))))

        return MY_XML_ERROR;

      bzero(newcs,sizeof(CHARSET_INFO));

    }

    else

    {

      /* Don't allow change of csname */

      if (newcs->cs_name.str && strcmp(newcs->cs_name.str, cs->cs_name.str))

      {

        my_error(EE_DUPLICATE_CHARSET, MYF(ME_WARNING),

                 cs->number, cs->cs_name.str, newcs->cs_name.str);

        /*

          Continue parsing rest of Index.xml. We got an warning in the log

          so the user can fix the wrong character set definition.

        */

        return MY_XML_OK;

      }

    }

    if (cs->primary_number == cs->number)

      cs->state |= MY_CS_PRIMARY;

    if (cs->binary_number == cs->number)

      cs->state |= MY_CS_BINSORT;

    newcs->state|= cs->state;

    if (!(newcs->state & MY_CS_COMPILED))

    {

      if (cs_copy_data(newcs,cs))

        return MY_XML_ERROR;

      newcs->levels_for_order= 1;

      if (!strcmp(cs->cs_name.str,"ucs2") )

      {

#if defined(HAVE_CHARSET_ucs2) && defined(HAVE_UCA_COLLATIONS)

        copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?

                                  &my_charset_ucs2_unicode_nopad_ci :

                                  &my_charset_ucs2_unicode_ci,

                                  cs);

        newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;

#endif        

      }

      else if (!strcmp(cs->cs_name.str, "utf8") ||

               !strcmp(cs->cs_name.str, "utf8mb3"))

      {

#if defined (HAVE_CHARSET_utf8mb3) && defined(HAVE_UCA_COLLATIONS)

        copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?

                                  &my_charset_utf8mb3_unicode_nopad_ci :

                                  &my_charset_utf8mb3_unicode_ci,

                                  cs);

        newcs->m_ctype= my_charset_utf8mb3_unicode_ci.m_ctype;

        if (init_state_maps(newcs))

          return MY_XML_ERROR;

#endif

      }

      else if (!strcmp(cs->cs_name.str, "utf8mb4"))

      {

#if defined (HAVE_CHARSET_utf8mb4) && defined(HAVE_UCA_COLLATIONS)

        copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?

                                  &my_charset_utf8mb4_unicode_nopad_ci :

                                  &my_charset_utf8mb4_unicode_ci,

                                  cs);

        newcs->m_ctype= my_charset_utf8mb4_unicode_ci.m_ctype;

        if (init_state_maps(newcs))

          return MY_XML_ERROR;

        newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED;

#endif

      }

      else if (!strcmp(cs->cs_name.str, "utf16"))

      {

#if defined (HAVE_CHARSET_utf16) && defined(HAVE_UCA_COLLATIONS)

        copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?

                                  &my_charset_utf16_unicode_nopad_ci :

                                  &my_charset_utf16_unicode_ci,

                                  cs);

        newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;

#endif

      }

      else if (!strcmp(cs->cs_name.str, "utf32"))

      {

#if defined (HAVE_CHARSET_utf32) && defined(HAVE_UCA_COLLATIONS)

        copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?

                                  &my_charset_utf32_unicode_nopad_ci :

                                  &my_charset_utf32_unicode_ci,

                                  cs);

        newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;

#endif

      }

      else

      {

        simple_cs_init_functions(newcs);

        newcs->mbminlen= 1;

        newcs->mbmaxlen= 1;

        newcs->strxfrm_multiply= 1;

        if (simple_cs_is_full(newcs))

        {

          newcs->state |= MY_CS_LOADED;

        }

      }

      add_compiled_extra_collation(newcs);

    }

    else

    {

      /*

        We need the below to make get_charset_name()

        and get_charset_number() working even if a

        character set has not been really incompiled.

        The above functions are used for example

        in error message compiler extra/comp_err.c.

        If a character set was compiled, this information

        will get lost and overwritten in add_compiled_collation().

      */

      newcs->number= cs->number;

      if (cs->comment)

  if (!(newcs->comment= my_once_strdup(cs->comment,MYF(MY_WME))))

    return MY_XML_ERROR;

      if (cs->cs_name.str && ! newcs->cs_name.str)

      {

        if (!(newcs->cs_name.str= my_once_memdup(cs->cs_name.str,

                                                 cs->cs_name.length+1,

                                                 MYF(MY_WME))))

    return MY_XML_ERROR;

        newcs->cs_name.length= cs->cs_name.length;

      }

      if (cs->coll_name.str)

      {

  if (!(newcs->coll_name.str= my_once_memdup(cs->coll_name.str,

                                                   cs->coll_name.length+1,

                                                  MYF(MY_WME))))

    return MY_XML_ERROR;

        newcs->coll_name.length= cs->coll_name.length;

      }

    }

    cs->number= 0;

    cs->primary_number= 0;

    cs->binary_number= 0;

    cs->coll_name.str= 0;

    cs->coll_name.length= 0;

    cs->state= 0;

    cs->sort_order= NULL;

    cs->tailoring= NULL;

  }

  return MY_XML_OK;

}

/**

  Report character set initialization errors and warnings.

  Be silent by default: no warnings on the client side.

*/

static void

default_reporter(enum loglevel level  __attribute__ ((unused)),

                 const char *format  __attribute__ ((unused)),

                 ...)

{

}

my_error_reporter my_charset_error_reporter= default_reporter;

/**

  Wrappers for memory functions my_malloc (and friends)

  with C-compatbile API without extra "myf" argument.

*/

static void *

my_once_alloc_c(size_t size)

{ return my_once_alloc(size, MYF(MY_WME)); }

static void *

my_malloc_c(size_t size)

{ return my_malloc(key_memory_charset_loader, size, MYF(MY_WME)); }

static void *

my_realloc_c(void *old, size_t size)

{ return my_realloc(key_memory_charset_loader, old, size, MYF(MY_WME|MY_ALLOW_ZERO_PTR)); }

/**

  Initialize character set loader to use mysys memory management functions.

  @param loader  Loader to initialize

*/

void

my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader)

{

  loader->error[0]= '\0';

  loader->once_alloc= my_once_alloc_c;

  loader->malloc= my_malloc_c;

  loader->realloc= my_realloc_c;

  loader->free= my_free;

  loader->reporter= my_charset_error_reporter;

  loader->add_collation= add_collation;

}

#define MY_MAX_ALLOWED_BUF 1024*1024

#define MY_CHARSET_INDEX "Index.xml"

const char *charsets_dir= NULL;

static my_bool

my_read_charset_file(MY_CHARSET_LOADER *loader,

                     const char *filename,

                     myf myflags)

{

  uchar *buf;

  int  fd;

  size_t len, tmp_len;

  MY_STAT stat_info;

  if (!my_stat(filename, &stat_info, MYF(myflags)) ||

       ((len= (uint)stat_info.st_size) > MY_MAX_ALLOWED_BUF) ||

       !(buf= (uchar*) my_malloc(key_memory_charset_loader,len,myflags)))

    return TRUE;

  if ((fd= mysql_file_open(key_file_charset, filename, O_RDONLY, myflags)) < 0)

    goto error;

  tmp_len= mysql_file_read(fd, buf, len, myflags);

  mysql_file_close(fd, myflags);

  if (tmp_len != len)

    goto error;

  if (my_parse_charset_xml(loader, (char *) buf, len))

  {

    my_printf_error(EE_UNKNOWN_CHARSET, "Error while parsing '%s': %s\n",

                    MYF(0), filename, loader->error);

    goto error;

  }

  my_free(buf);

  return FALSE;

error:

  my_free(buf);

  return TRUE;

}

char *get_charsets_dir(char *buf)

{

  const char *sharedir= SHAREDIR;

  char *res;

  DBUG_ENTER("get_charsets_dir");

  if (charsets_dir != NULL)

    strmake(buf, charsets_dir, FN_REFLEN-1);

  else

  {

    if (test_if_hard_path(sharedir) ||

  is_prefix(sharedir, DEFAULT_CHARSET_HOME))

      strxmov(buf, sharedir, "/", CHARSET_DIR, NullS);

    else

      strxmov(buf, DEFAULT_CHARSET_HOME, "/", sharedir, "/", CHARSET_DIR,

        NullS);

  }

  res= convert_dirname(buf,buf,NullS);

  DBUG_PRINT("info",("charsets dir: '%s'", buf));

  DBUG_RETURN(res);

}

CHARSET_INFO *all_charsets[MY_ALL_CHARSETS_SIZE]={NULL};

CHARSET_INFO *default_charset_info = &my_charset_latin1;

/*

  Add standard character set compiled into the application

  All related character sets should share same cname

*/

void add_compiled_collation(struct charset_info_st *cs)

{

  DBUG_ASSERT(cs->number < array_elements(all_charsets));

  all_charsets[cs->number]= cs;

  cs->state|= MY_CS_AVAILABLE;

  if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))

  {

#ifndef DBUG_OFF

    CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,

                                                      (uchar*) cs->cs_name.str,

                                                      cs->cs_name.length);

    DBUG_ASSERT(org);

    DBUG_ASSERT(org->cs_name.str == cs->cs_name.str);

    DBUG_ASSERT(org->cs_name.length == strlen(cs->cs_name.str));

#endif

  }

}

/*

  Add optional characters sets from ctype-extra.c

  If cname is already in use, replace csname in new object with a pointer to

  the already used csname to ensure that all csname's points to the same string

  for the same character set.

*/

void add_compiled_extra_collation(struct charset_info_st *cs)

{

  DBUG_ASSERT(cs->number < array_elements(all_charsets));

  all_charsets[cs->number]= cs;

  cs->state|= MY_CS_AVAILABLE;

  if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))

  {

    CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,

                                                      (uchar*) cs->cs_name.str,

                                                      cs->cs_name.length);

    cs->cs_name= org->cs_name;

  }

}

static my_pthread_once_t charsets_initialized= MY_PTHREAD_ONCE_INIT;

static my_pthread_once_t charsets_template= MY_PTHREAD_ONCE_INIT;

typedef struct

{

  ulonglong use_count;

} MY_COLLATION_STATISTICS;

static MY_COLLATION_STATISTICS my_collation_statistics[MY_ALL_CHARSETS_SIZE];

my_bool my_collation_is_known_id(uint id)

{

  return id > 0 && id < array_elements(all_charsets) && all_charsets[id] ?

         TRUE : FALSE;

}

/*

  Collation use statistics functions do not lock

  counters to avoid mutex contention. This can lose

  some counter increments with high thread concurrency.

  But this should be Ok, as we don't need exact numbers.

*/

static inline void my_collation_statistics_inc_use_count(uint id)

{

  DBUG_ASSERT(my_collation_is_known_id(id));

  my_collation_statistics[id].use_count++;

}

ulonglong my_collation_statistics_get_use_count(uint id)

{

  DBUG_ASSERT(my_collation_is_known_id(id));

  return my_collation_statistics[id].use_count;

}

const char *my_collation_get_tailoring(uint id)

{

  /* all_charsets[id]->tailoring is never changed after server startup. */

  DBUG_ASSERT(my_collation_is_known_id(id));

  return all_charsets[id]->tailoring;

}

HASH charset_name_hash;

static uchar *get_charset_key(const uchar *object,

                              size_t *size,

                              my_bool not_used __attribute__((unused)))

{

  CHARSET_INFO *cs= (CHARSET_INFO*) object;

  *size= cs->cs_name.length;

  return (uchar*) cs->cs_name.str;

}

static void init_available_charsets(void)

{

  char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];

  struct charset_info_st **cs;

  MY_CHARSET_LOADER loader;

  DBUG_ENTER("init_available_charsets");

  bzero((char*) &all_charsets,sizeof(all_charsets));

  bzero((char*) &my_collation_statistics, sizeof(my_collation_statistics));

  my_hash_init2(key_memory_charsets, &charset_name_hash, 16,

                &my_charset_latin1, 64, 0, 0, get_charset_key,

                0, 0, HASH_UNIQUE);

  init_compiled_charsets(MYF(0));

  /* Copy compiled charsets */

  for (cs= (struct charset_info_st**) all_charsets;

       cs < (struct charset_info_st**) all_charsets +

            array_elements(all_charsets)-1 ;

       cs++)

  {

    if (*cs)

    {

      DBUG_ASSERT(cs[0]->mbmaxlen <= MY_CS_MBMAXLEN);

      if (cs[0]->m_ctype)

        if (init_state_maps(*cs))

          *cs= NULL;

    }

  }

  my_charset_loader_init_mysys(&loader);

  strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);

  my_read_charset_file(&loader, fname, MYF(0));

  DBUG_VOID_RETURN;

}

void free_charsets(void)

{

  charsets_initialized= charsets_template;

  my_hash_free(&charset_name_hash);

}

static const char*

get_collation_name_alias(const char *name, char *buf, size_t bufsize, myf flags)

{

  if (!strncasecmp(name, "utf8_", 5))

  {

    my_snprintf(buf, bufsize, "utf8mb%c_%s",

       flags & MY_UTF8_IS_UTF8MB3 ? '3' : '4', name + 5);

    return buf;

  }

  return NULL;

}

uint get_collation_number(const char *name, myf flags)

{

  uint id;

  char alias[64];

  my_pthread_once(&charsets_initialized, init_available_charsets);

  if ((id= get_collation_number_internal(name)))

    return id;

  if ((name= get_collation_name_alias(name, alias, sizeof(alias),flags)))

    return get_collation_number_internal(name);

  return 0;

}

static uint

get_charset_number_internal(const char *charset_name, uint cs_flags)

{

  CHARSET_INFO **cs;

  for (cs= all_charsets;

       cs < all_charsets + array_elements(all_charsets);

       cs++)

  {

    if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&

         !my_strcasecmp_latin1(cs[0]->cs_name.str, charset_name))

      return cs[0]->number;

  }  

  return 0;

}

uint get_charset_number(const char *charset_name, uint cs_flags, myf flags)

{

  uint id;

  const char *new_charset_name= flags & MY_UTF8_IS_UTF8MB3 ? "utf8mb3" :

                                                             "utf8mb4";

  my_pthread_once(&charsets_initialized, init_available_charsets);

  if ((id= get_charset_number_internal(charset_name, cs_flags)))

    return id;

  if ((charset_name= !my_strcasecmp_latin1(charset_name, "utf8") ?

                      new_charset_name : NULL))

    return get_charset_number_internal(charset_name, cs_flags);

  return 0;

}

const char *get_charset_name(uint charset_number)

{

  my_pthread_once(&charsets_initialized, init_available_charsets);

  if (charset_number < array_elements(all_charsets))

  {

    CHARSET_INFO *cs= all_charsets[charset_number];

    if (cs && (cs->number == charset_number) && cs->coll_name.str)

      return cs->coll_name.str;

  }

  return "?";   /* this mimics find_type() */

}

static CHARSET_INFO *inheritance_source_by_id(CHARSET_INFO *cs, uint refid)

{

  CHARSET_INFO *refcs;

  return refid && refid != cs->number &&

         (refcs= all_charsets[refid]) &&

         (refcs->state & MY_CS_AVAILABLE) ? refcs : NULL;

}

static CHARSET_INFO *find_collation_data_inheritance_source(CHARSET_INFO *cs, myf flags)

{

  const char *beg, *end;

  if (cs->tailoring &&

      !strncmp(cs->tailoring, "[import ", 8) &&

      (end= strchr(cs->tailoring + 8, ']')) &&

      (beg= cs->tailoring + 8) + MY_CS_COLLATION_NAME_SIZE > end)

  {

    char name[MY_CS_COLLATION_NAME_SIZE + 1];

    memcpy(name, beg, end - beg);

    name[end - beg]= '\0';

    return inheritance_source_by_id(cs, get_collation_number(name,MYF(flags)));

  }

  return NULL;

}

static CHARSET_INFO *find_charset_data_inheritance_source(CHARSET_INFO *cs)

{

  uint refid= get_charset_number_internal(cs->cs_name.str, MY_CS_PRIMARY);

  return inheritance_source_by_id(cs, refid);

}

static CHARSET_INFO *

get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)

{

  char  buf[FN_REFLEN];

  struct charset_info_st *cs;

  DBUG_ASSERT(cs_number < array_elements(all_charsets));

  if ((cs= (struct charset_info_st*) all_charsets[cs_number]))

  {

    if (cs->state & MY_CS_READY)  /* if CS is already initialized */

    {

      my_collation_statistics_inc_use_count(cs_number);

      return cs;

    }

    /*

      To make things thread safe we are not allowing other threads to interfere

      while we may changing the cs_info_table

    */

    mysql_mutex_lock(&THR_LOCK_charset);

    if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */

    {

      MY_CHARSET_LOADER loader;

      strxmov(get_charsets_dir(buf), cs->cs_name.str, ".xml", NullS);

      my_charset_loader_init_mysys(&loader);

      my_read_charset_file(&loader, buf, flags);