post-merge fixes.

most tests pass.
5.3 merge is next

2 files changed, 178 insertions, 88 deletions

diff --git a/strings/ctype-mb.c b/strings/ctype-mb.c
index 8d864dfaad5..14dcacdbd60 100644
--- a/strings/ctype-mb.c
+++ b/strings/ctype-mb.c
@@ -1,4 +1,5 @@
-/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
+   Copyright (c) 2009-2011, Monty Program Ab
 
    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
@@ -683,6 +684,7 @@ my_bool my_like_range_mb(CHARSET_INFO *cs,
   char *min_end= min_str + res_length;
   char *max_end= max_str + res_length;
   size_t maxcharlen= res_length / cs->mbmaxlen;
+  my_bool have_contractions= my_cs_have_contractions(cs);
 
   for (; ptr != end && min_str != min_end && maxcharlen ; maxcharlen--)
   {
@@ -750,8 +752,8 @@ fill_max_and_min:
         'ab\min\min\min\min' and 'ab\max\max\max\max'.
 
       */
-      if (contraction_flags && ptr + 1 < end &&
-          contraction_flags[(uchar) *ptr])
+      if (have_contractions && ptr + 1 < end &&
+          my_cs_can_be_contraction_head(cs, (uchar) *ptr))
       {
         /* Ptr[0] is a contraction head. */
         
@@ -773,8 +775,8 @@ fill_max_and_min:
           is not a contraction, then we put only ptr[0],
           and continue with ptr[1] on the next loop.
         */
-        if (contraction_flags[(uchar) ptr[1]] &&
-            cs->contractions[(*ptr-0x40)*0x40 + ptr[1] - 0x40])
+        if (my_cs_can_be_contraction_tail(cs, (uchar) ptr[1]) &&
+            my_cs_contraction2_weight(cs, (uchar) ptr[0], (uchar) ptr[1]))
         {
           /* Contraction found */
           if (maxcharlen == 1 || min_str + 1 >= min_end)
@@ -911,7 +913,7 @@ my_like_range_generic(CHARSET_INFO *cs,
         my_cs_can_be_contraction_head(cs, wc) &&
         (res= cs->cset->mb_wc(cs, &wc2, (uchar*) ptr, (uchar*) end)) > 0)
     {
-      uint16 *weight;
+      const uint16 *weight;
       if ((wc2 == (my_wc_t) w_one || wc2 == (my_wc_t) w_many))
       {
         /* Contraction head followed by a wildcard */
diff --git a/strings/ctype-uca.c b/strings/ctype-uca.c
index a8b12e13e39..4a77728b227 100644
--- a/strings/ctype-uca.c
+++ b/strings/ctype-uca.c
@@ -1,4 +1,5 @@
-/* Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2004, 2011, Oracle and/or its affiliates.
+   Copyright (c) 2009-2011, Monty Program Ab
    
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
@@ -31,10 +32,15 @@
    - No combining marks processing is done
 */
 
+
 #include <my_global.h>
 #include "m_string.h"
 #include "m_ctype.h"
 
+#define MY_UCA_CNT_FLAG_SIZE 4096
+#define MY_UCA_CNT_FLAG_MASK 4095
+#define MY_UCA_CNT_HEAD 1
+#define MY_UCA_CNT_TAIL 2
 
 #ifdef HAVE_UCA_COLLATIONS
 
@@ -6454,7 +6460,6 @@ static const uchar uca_length[256]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,3,3,4,3,9,3,3
 };
-
 static const uint16 *const uca_weight[256]={
 page000data,page001data,page002data,page003data,
 page004data,page005data,page006data,page007data,
@@ -6765,7 +6770,7 @@ typedef struct my_uca_scanner_st
   const uchar  *send;	/* End of the input string                */
   const uchar *uca_length;
   const uint16 * const *uca_weight;
-  uint16 *contractions;
+  const MY_CONTRACTIONS *contractions;
   uint16 implicit[2];
   int page;
   int code;
@@ -6785,6 +6790,80 @@ typedef struct my_uca_scanner_handler_st
 
 static const uint16 nochar[]= {0,0};
 
+/********** Helper functions to handle contraction ************/
+
+
+/**
+  Mark a character as a contraction part
+  
+  @cs       Pointer to CHARSET_INFO data
+  @wc       Unicode code point
+  @flag     flag: "is contraction head", "is contraction tail"
+*/
+
+static void
+my_uca_add_contraction_flag(CHARSET_INFO *cs, my_wc_t wc, int flag)
+{
+  cs->contractions->flags[wc & MY_UCA_CNT_FLAG_MASK]|= flag;
+}
+
+
+/**
+  Add a new contraction into contraction list
+  
+  @cs       Pointer to CHARSET_INFO data
+  @wc       Unicode code points of the characters
+  @len      Number of characters
+  
+  @return   New contraction
+  @retval   Pointer to a newly added contraction
+*/
+
+static MY_CONTRACTION *
+my_uca_add_contraction(struct charset_info_st *cs,
+                       my_wc_t *wc, int len __attribute__((unused)))
+{
+  MY_CONTRACTIONS *list= (MY_CONTRACTIONS*) cs->contractions;
+  MY_CONTRACTION *next= &list->item[list->nitems];
+  DBUG_ASSERT(len == 2); /* We currently support only contraction2 */
+  next->ch[0]= wc[0];
+  next->ch[1]= wc[1];
+  list->nitems++;
+  return next;
+}
+
+
+/**
+  Allocate and initialize memory for contraction list and flags
+  
+  @cs       Pointer to CHARSET_INFO data
+  @alloc    Memory allocation function (typically points to my_alloc_once)
+  @n        Number of contractions
+  
+  @return   Error code
+  @retval   0 - memory allocated successfully
+  @retval   1 - not enough memory
+*/
+
+static my_bool
+my_uca_alloc_contractions(struct charset_info_st *cs,
+                          void *(*alloc)(size_t), size_t n)
+{
+  uint size= n * sizeof(MY_CONTRACTION);
+  MY_CONTRACTIONS *contractions;
+
+  if (!(cs->contractions= contractions= (*alloc)(sizeof(MY_CONTRACTIONS))))
+    return 1;
+  bzero(contractions, sizeof(MY_CONTRACTIONS));
+  if (!(contractions->item= (*alloc)(size)) ||
+      !(contractions->flags= (char*) (*alloc)(MY_UCA_CNT_FLAG_SIZE)))
+    return 1;
+  bzero(contractions->item, size);
+  bzero(contractions->flags, MY_UCA_CNT_FLAG_SIZE);
+  return 0;
+}
+
+
 #ifdef HAVE_CHARSET_ucs2
 /*
   Initialize collation weight scanner
@@ -6804,7 +6883,7 @@ static const uint16 nochar[]= {0,0};
 */
 
 static void my_uca_scanner_init_ucs2(my_uca_scanner *scanner,
-                                     CHARSET_INFO *cs __attribute__((unused)),
+                                     CHARSET_INFO *cs,
                                      const uchar *str, size_t length)
 {
   scanner->wbeg= nochar; 
@@ -6815,6 +6894,7 @@ static void my_uca_scanner_init_ucs2(my_uca_scanner *scanner,
     scanner->uca_length= cs->sort_order;
     scanner->uca_weight= cs->sort_order_big;
     scanner->contractions= cs->contractions;
+    scanner->cs= cs;
     return;
   }
 
@@ -6903,18 +6983,23 @@ static int my_uca_scanner_next_ucs2(my_uca_scanner *scanner)
     
     if (scanner->contractions && (scanner->sbeg <= scanner->send))
     {
-      int cweight;
+      my_wc_t wc1= ((scanner->page << 8) | scanner->code);
       
-      if (!scanner->page && !scanner->sbeg[0] &&
-          (scanner->sbeg[1] > 0x40) && (scanner->sbeg[1] < 0x80) &&
-          (scanner->code > 0x40) && (scanner->code < 0x80) &&
-          (cweight= scanner->contractions[(scanner->code-0x40)*0x40+scanner->sbeg[1]-0x40]))
+      if (my_cs_can_be_contraction_head(scanner->cs, wc1))
+      {
+        const uint16 *cweight;
+        my_wc_t wc2= (((my_wc_t) scanner->sbeg[0]) << 8) | scanner->sbeg[1];
+        if (my_cs_can_be_contraction_tail(scanner->cs, wc2) &&
+          (cweight= my_cs_contraction2_weight(scanner->cs,
+                                               scanner->code,
+                                               scanner->sbeg[1])))
         {
           scanner->implicit[0]= 0;
           scanner->wbeg= scanner->implicit;
           scanner->sbeg+=2;
-          return cweight;
+          return *cweight;
         }
+      }
     }
     
     if (!ucaw[scanner->page])
@@ -7006,23 +7091,22 @@ static int my_uca_scanner_next_any(my_uca_scanner *scanner)
       scanner->code= wc & 0xFF;
     }
     
-    if (scanner->contractions && !scanner->page &&
-        (scanner->code > 0x40) && (scanner->code < 0x80))
+    if (my_cs_have_contractions(scanner->cs) &&
+        my_cs_can_be_contraction_head(scanner->cs, wc))
     {
-      uint page1, code1, cweight;
+      my_wc_t wc2;
+      const uint16 *cweight;
       
-      if (((mb_len= scanner->cs->cset->mb_wc(scanner->cs, &wc,
+      if (((mb_len= scanner->cs->cset->mb_wc(scanner->cs, &wc2,
                                             scanner->sbeg, 
                                             scanner->send)) >=0) &&
-           (!(page1= (wc >> 8))) &&
-           ((code1= (wc & 0xFF)) > 0x40) &&
-           (code1 < 0x80) && 
-           (cweight= scanner->contractions[(scanner->code-0x40)*0x40 + code1-0x40]))
+           my_cs_can_be_contraction_tail(scanner->cs, wc2) &&
+          (cweight= my_cs_contraction2_weight(scanner->cs, wc, wc2)))
       {
         scanner->implicit[0]= 0;
         scanner->wbeg= scanner->implicit;
         scanner->sbeg+= mb_len;
-        return cweight;
+        return *cweight;
       }
     }
     
@@ -7060,6 +7144,29 @@ static my_uca_scanner_handler my_any_uca_scanner_handler=
 };
 
 
+/**
+  Helper function:
+  Find address of weights of the given character.
+
+  @weights  UCA weight array
+  @lengths  UCA length array
+  @ch       character Unicode code point
+
+  @return Weight array
+  @retval  pointer to weight array for the given character,
+           or NULL if this page does not have implicit weights.
+*/
+
+static inline const uint16 *
+my_char_weight_addr(CHARSET_INFO *cs, uint wc)
+{
+  uint page= (wc >> 8);
+  uint ofst= wc & 0xFF;
+  return (cs->sort_order_big[page] ?
+          cs->sort_order_big[page] + ofst * cs->sort_order[page] :
+          0);
+}
+
 
 /*
   Compares two strings according to the collation
@@ -7737,8 +7844,8 @@ ex:
 
 typedef struct my_coll_rule_item_st
 {
-  uint base;     /* Base character                             */
-  uint curr[2];  /* Current character                          */
+  my_wc_t base;     /* Base character                             */
+  my_wc_t curr[2];  /* Current character                          */
   int diff[3];   /* Primary, Secondary and Tertiary difference */
 } MY_COLL_RULE;
 
@@ -7893,6 +8000,7 @@ static my_bool create_tailoring(struct charset_info_st *cs,
                                 void *(*alloc)(size_t))
 {
   MY_COLL_RULE rule[MY_MAX_COLL_RULE];
+  MY_COLL_RULE *r, *rfirst, *rlast;
   char errstr[128];
   uchar   *newlengths;
   uint16 **newweights;
@@ -7917,6 +8025,9 @@ static my_bool create_tailoring(struct charset_info_st *cs,
     return 1;
   }
   
+  rfirst= rule;
+  rlast= rule + rc;
+  
   if (!cs->caseinfo)
     cs->caseinfo= my_unicase_default;
   
@@ -8000,44 +8111,21 @@ static my_bool create_tailoring(struct charset_info_st *cs,
   /* Now process contractions */
   if (ncontractions)
   {
-    /*
-      8K for weights for basic latin letter pairs,
-      plus 256 bytes for "is contraction part" flags.
-    */
-    uint size= 0x40*0x40*sizeof(uint16) + 256;
-    char *contraction_flags;
-    if (!(cs->contractions= (uint16*) (*alloc)(size)))
-        return 1;
-    bzero((void*)cs->contractions, size);
-    contraction_flags= ((char*) cs->contractions) + 0x40*0x40;
-    for (i=0; i < rc; i++)
+    if (my_uca_alloc_contractions(cs, alloc, ncontractions))
+      return 1;
+    for (r= rfirst; r < rlast; r++)
     {
-      if (rule[i].curr[1])
+      uint16 *to;
+      if (r->curr[1]) /* Contraction */
       {
-        uint pageb= (rule[i].base >> 8) & 0xFF;
-        uint chb= rule[i].base & 0xFF;
-        uint16 *offsb= defweights[pageb] + chb*deflengths[pageb];
-        uint offsc;
-        
-        if (offsb[1] || 
-            rule[i].curr[0] < 0x40 || rule[i].curr[0] > 0x7f ||
-            rule[i].curr[1] < 0x40 || rule[i].curr[1] > 0x7f)
-        {
-          /* 
-           TODO: add error reporting;
-           We support only basic latin letters contractions at this point.
-           Also, We don't support contractions with weight longer than one.
-           Otherwise, we'd need much more memory.
-          */
-          return 1;
-        }
-        offsc= (rule[i].curr[0]-0x40)*0x40+(rule[i].curr[1]-0x40);
-        
-        /* Copy base weight applying primary difference */
-        cs->contractions[offsc]= offsb[0] + rule[i].diff[0];
-        /* Mark both letters as "is contraction part */
-        contraction_flags[rule[i].curr[0]]= 1;
-        contraction_flags[rule[i].curr[1]]= 1;
+        /* Mark both letters as "is contraction part" */
+        my_uca_add_contraction_flag(cs, r->curr[0], MY_UCA_CNT_HEAD);
+        my_uca_add_contraction_flag(cs, r->curr[1], MY_UCA_CNT_TAIL);
+        to= my_uca_add_contraction(cs, r->curr, 2)->weight;
+        /* Copy weight from the reset character */
+        to[0]= my_char_weight_addr(cs, r->base)[0];
+        /* Apply primary difference */
+        to[0]+= r->diff[0];
       }
     }
   }
@@ -8763,7 +8851,7 @@ struct charset_info_st my_charset_ucs2_hungarian_uca_ci=
 struct charset_info_st my_charset_ucs2_sinhala_uca_ci=
 {
     147,0,0,             /* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
     "ucs2",              /* csname    */
     "ucs2_sinhala_ci",   /* name         */
     "",                  /* comment      */
@@ -8795,7 +8883,7 @@ struct charset_info_st my_charset_ucs2_sinhala_uca_ci=
 struct charset_info_st my_charset_ucs2_croatian_uca_ci=
 {
     149,0,0,             /* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
     "ucs2",              /* cs name    */
     "ucs2_croatian_ci",  /* name         */
     "",                  /* comment      */
@@ -8874,7 +8962,7 @@ extern MY_CHARSET_HANDLER my_charset_utf8_handler;
 struct charset_info_st my_charset_utf8_unicode_ci=
 {
     192,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_unicode_ci",	/* name         */
     "",			/* comment      */
@@ -8907,7 +8995,7 @@ struct charset_info_st my_charset_utf8_unicode_ci=
 struct charset_info_st my_charset_utf8_icelandic_uca_ci=
 {
     193,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_icelandic_ci",/* name         */
     "",			/* comment      */
@@ -8939,7 +9027,7 @@ struct charset_info_st my_charset_utf8_icelandic_uca_ci=
 struct charset_info_st my_charset_utf8_latvian_uca_ci=
 {
     194,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_latvian_ci",	/* name         */
     "",			/* comment      */
@@ -8971,7 +9059,7 @@ struct charset_info_st my_charset_utf8_latvian_uca_ci=
 struct charset_info_st my_charset_utf8_romanian_uca_ci=
 {
     195,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_romanian_ci",	/* name         */
     "",			/* comment      */
@@ -9003,7 +9091,7 @@ struct charset_info_st my_charset_utf8_romanian_uca_ci=
 struct charset_info_st my_charset_utf8_slovenian_uca_ci=
 {
     196,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_slovenian_ci",/* name         */
     "",			/* comment      */
@@ -9035,7 +9123,7 @@ struct charset_info_st my_charset_utf8_slovenian_uca_ci=
 struct charset_info_st my_charset_utf8_polish_uca_ci=
 {
     197,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_polish_ci",	/* name         */
     "",			/* comment      */
@@ -9067,7 +9155,7 @@ struct charset_info_st my_charset_utf8_polish_uca_ci=
 struct charset_info_st my_charset_utf8_estonian_uca_ci=
 {
     198,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_estonian_ci",	/* name         */
     "",			/* comment      */
@@ -9099,7 +9187,7 @@ struct charset_info_st my_charset_utf8_estonian_uca_ci=
 struct charset_info_st my_charset_utf8_spanish_uca_ci=
 {
     199,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_spanish_ci",	/* name         */
     "",			/* comment      */
@@ -9131,7 +9219,7 @@ struct charset_info_st my_charset_utf8_spanish_uca_ci=
 struct charset_info_st my_charset_utf8_swedish_uca_ci=
 {
     200,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_swedish_ci",	/* name         */
     "",			/* comment      */
@@ -9163,7 +9251,7 @@ struct charset_info_st my_charset_utf8_swedish_uca_ci=
 struct charset_info_st my_charset_utf8_turkish_uca_ci=
 {
     201,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_turkish_ci",	/* name         */
     "",			/* comment      */
@@ -9195,7 +9283,7 @@ struct charset_info_st my_charset_utf8_turkish_uca_ci=
 struct charset_info_st my_charset_utf8_czech_uca_ci=
 {
     202,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_czech_ci",	/* name         */
     "",			/* comment      */
@@ -9228,7 +9316,7 @@ struct charset_info_st my_charset_utf8_czech_uca_ci=
 struct charset_info_st my_charset_utf8_danish_uca_ci=
 {
     203,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_danish_ci",	/* name         */
     "",			/* comment      */
@@ -9260,7 +9348,7 @@ struct charset_info_st my_charset_utf8_danish_uca_ci=
 struct charset_info_st my_charset_utf8_lithuanian_uca_ci=
 {
     204,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_lithuanian_ci",/* name         */
     "",			/* comment      */
@@ -9292,7 +9380,7 @@ struct charset_info_st my_charset_utf8_lithuanian_uca_ci=
 struct charset_info_st my_charset_utf8_slovak_uca_ci=
 {
     205,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_slovak_ci",	/* name         */
     "",			/* comment      */
@@ -9324,7 +9412,7 @@ struct charset_info_st my_charset_utf8_slovak_uca_ci=
 struct charset_info_st my_charset_utf8_spanish2_uca_ci=
 {
     206,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_spanish2_ci",	/* name         */
     "",			/* comment      */
@@ -9356,7 +9444,7 @@ struct charset_info_st my_charset_utf8_spanish2_uca_ci=
 struct charset_info_st my_charset_utf8_roman_uca_ci=
 {
     207,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_roman_ci",	/* name         */
     "",			/* comment      */
@@ -9388,7 +9476,7 @@ struct charset_info_st my_charset_utf8_roman_uca_ci=
 struct charset_info_st my_charset_utf8_persian_uca_ci=
 {
     208,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_persian_ci",	/* name         */
     "",			/* comment      */
@@ -9420,7 +9508,7 @@ struct charset_info_st my_charset_utf8_persian_uca_ci=
 struct charset_info_st my_charset_utf8_esperanto_uca_ci=
 {
     209,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_esperanto_ci",/* name         */
     "",			/* comment      */
@@ -9452,7 +9540,7 @@ struct charset_info_st my_charset_utf8_esperanto_uca_ci=
 struct charset_info_st my_charset_utf8_hungarian_uca_ci=
 {
     210,0,0,		/* number       */
-    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
+    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE,
     "utf8",		/* cs name    */
     "utf8_hungarian_ci",/* name         */
     "",			/* comment      */
@@ -11637,7 +11725,7 @@ struct charset_info_st my_charset_utf16_croatian_uca_ci=
 */
 
 my_bool
-my_uca_have_contractions(CHARSET_INFO *cs)
+my_cs_have_contractions(CHARSET_INFO *cs)
 {
   return cs->contractions != NULL;
 }
@@ -11653,7 +11741,7 @@ my_uca_have_contractions(CHARSET_INFO *cs)
 */
 
 my_bool
-my_uca_can_be_contraction_head(CHARSET_INFO *cs, my_wc_t wc)
+my_cs_can_be_contraction_head(CHARSET_INFO *cs, my_wc_t wc)
 {
   return cs->contractions->flags[wc & MY_UCA_CNT_FLAG_MASK] & MY_UCA_CNT_HEAD;
 }
@@ -11670,7 +11758,7 @@ my_uca_can_be_contraction_head(CHARSET_INFO *cs, my_wc_t wc)
 */
 
 my_bool
-my_uca_can_be_contraction_tail(CHARSET_INFO *cs, my_wc_t wc)
+my_cs_can_be_contraction_tail(CHARSET_INFO *cs, my_wc_t wc)
 {
   return cs->contractions->flags[wc & MY_UCA_CNT_FLAG_MASK] & MY_UCA_CNT_TAIL;
 }
@@ -11689,7 +11777,7 @@ my_uca_can_be_contraction_tail(CHARSET_INFO *cs, my_wc_t wc)
 */
 
 const uint16 *
-my_uca_contraction2_weight(CHARSET_INFO *cs, my_wc_t wc1, my_wc_t wc2)
+my_cs_contraction2_weight(CHARSET_INFO *cs, my_wc_t wc1, my_wc_t wc2)
 {
   const MY_CONTRACTIONS *list= cs->contractions;
   const MY_CONTRACTION *c, *last;