开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ctype-ucs2.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：37k
源码类别：

MySQL数据库

开发平台：

Visual C++

ctype-ucs2.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  18. /* UCS2 support. Written by Alexander Barkov <bar@mysql.com> */
  20. #include <my_global.h>
  21. #include <my_sys.h>
  22. #include "m_string.h"
  23. #include "m_ctype.h"
  24. #include <errno.h>
  27. #ifdef HAVE_CHARSET_ucs2
  29. #ifndef EILSEQ
  30. #define EILSEQ ENOENT
  31. #endif
  33. extern MY_UNICASE_INFO *uni_plane[256];
  35. static uchar ctype_ucs2[] = {
  36.     0,
  37.    32, 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 32, 32,
  38.    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  39.    72, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
  40.   132,132,132,132,132,132,132,132,132,132, 16, 16, 16, 16, 16, 16,
  41.    16,129,129,129,129,129,129,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  42.     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 16, 16, 16, 16, 16,
  43.    16,130,130,130,130,130,130,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  44.     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 16, 16, 16, 16, 32,
  45.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  46.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  47.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  48.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  49.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  50.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  51.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  52.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  53. };
  55. static uchar to_lower_ucs2[] = {
  56.     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  57.    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  58.    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  59.    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  60.    64, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
  61.   112,113,114,115,116,117,118,119,120,121,122, 91, 92, 93, 94, 95,
  62.    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
  63.   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
  64.   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  65.   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  66.   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  67.   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  68.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  69.   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  70.   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
  71.   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
  72. };
  74. static uchar to_upper_ucs2[] = {
  75.     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  76.    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  77.    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  78.    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  79.    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  80.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  81.    96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  82.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
  83.   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  84.   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  85.   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  86.   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  87.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  88.   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  89.   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
  90.   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
  91. };
  94. static int my_ucs2_uni(CHARSET_INFO *cs __attribute__((unused)),
  95.        my_wc_t * pwc, const uchar *s, const uchar *e)
  96. {
  97.   if (s+2 > e) /* Need 2 characters */
  98.     return MY_CS_TOOFEW(0);
  99.   
  100.   *pwc= ((unsigned char)s[0]) * 256  + ((unsigned char)s[1]);
  101.   return 2;
  102. }
  104. static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
  105.        my_wc_t wc, uchar *r, uchar *e)
  106. {
  107.   if ( r+2 > e ) 
  108.     return MY_CS_TOOSMALL;
  109.   
  110.   r[0]= (uchar) (wc >> 8);
  111.   r[1]= (uchar) (wc & 0xFF);
  112.   return 2;
  113. }
  116. static void my_caseup_ucs2(CHARSET_INFO *cs, char *s, uint slen)
  117. {
  118.   my_wc_t wc;
  119.   int res;
  120.   char *e=s+slen;
  122.   while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
  123.   {
  124.     int plane = (wc>>8) & 0xFF;
  125.     wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].toupper : wc;
  126.     if (res != my_uni_ucs2(cs,wc,(uchar*)s,(uchar*)e))
  127.       break;
  128.     s+=res;
  129.   }
  130. }
  133. static void my_hash_sort_ucs2(CHARSET_INFO *cs, const uchar *s, uint slen,
  134.       ulong *n1, ulong *n2)
  135. {
  136.   my_wc_t wc;
  137.   int res;
  138.   const uchar *e=s+slen;
  140.   while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e)) >0)
  141.   {
  142.     int plane = (wc>>8) & 0xFF;
  143.     wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].sort : wc;
  144.     n1[0]^= (((n1[0] & 63)+n2[0])*(wc & 0xFF))+ (n1[0] << 8);
  145.     n2[0]+=3;
  146.     n1[0]^= (((n1[0] & 63)+n2[0])*(wc >> 8))+ (n1[0] << 8);
  147.     n2[0]+=3;
  148.     s+=res;
  149.   }
  150. }
  153. static void my_caseup_str_ucs2(CHARSET_INFO * cs  __attribute__((unused)), 
  154.        char * s __attribute__((unused)))
  155. {
  156. }
  160. static void my_casedn_ucs2(CHARSET_INFO *cs, char *s, uint slen)
  161. {
  162.   my_wc_t wc;
  163.   int res;
  164.   char *e=s+slen;
  166.   while ((s < e) && (res=my_ucs2_uni(cs, &wc, (uchar*)s, (uchar*)e))>0)
  167.   {
  168.     int plane = (wc>>8) & 0xFF;
  169.     wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].tolower : wc;
  170.     if (res != my_uni_ucs2(cs, wc, (uchar*)s, (uchar*)e))
  171.     {
  172.       break;
  173.     }
  174.     s+=res;
  175.   }
  176. }
  178. static void my_casedn_str_ucs2(CHARSET_INFO *cs __attribute__((unused)), 
  179.        char * s __attribute__((unused)))
  180. {
  181. }
  184. static int my_strnncoll_ucs2(CHARSET_INFO *cs, 
  185.      const uchar *s, uint slen, 
  186.                              const uchar *t, uint tlen,
  187.                              my_bool t_is_prefix)
  188. {
  189.   int s_res,t_res;
  190.   my_wc_t s_wc,t_wc;
  191.   const uchar *se=s+slen;
  192.   const uchar *te=t+tlen;
  194.   while ( s < se && t < te )
  195.   {
  196.     int plane;
  197.     s_res=my_ucs2_uni(cs,&s_wc, s, se);
  198.     t_res=my_ucs2_uni(cs,&t_wc, t, te);
  199.     
  200.     if ( s_res <= 0 || t_res <= 0 )
  201.     {
  202.       /* Incorrect string, compare by char value */
  203.       return ((int)s[0]-(int)t[0]); 
  204.     }
  205.     
  206.     plane=(s_wc>>8) & 0xFF;
  207.     s_wc = uni_plane[plane] ? uni_plane[plane][s_wc & 0xFF].sort : s_wc;
  208.     plane=(t_wc>>8) & 0xFF;
  209.     t_wc = uni_plane[plane] ? uni_plane[plane][t_wc & 0xFF].sort : t_wc;
  210.     if ( s_wc != t_wc )
  211.     {
  212.       return  s_wc > t_wc ? 1 : -1;
  213.     }
  214.     
  215.     s+=s_res;
  216.     t+=t_res;
  217.   }
  218.   return t_is_prefix ? (int) (t - te) : (int) ((se - s) - (te - t));
  219. }
  221. /*
  222.   Compare strings, discarding end space
  224.   SYNOPSIS
  225.     my_strnncollsp_ucs2()
  226.     cs                  character set handler
  227.     a                   First string to compare
  228.     a_length            Length of 'a'
  229.     b                   Second string to compare
  230.     b_length            Length of 'b'
  232.   IMPLEMENTATION
  233.     If one string is shorter as the other, then we space extend the other
  234.     so that the strings have equal length.
  236.     This will ensure that the following things hold:
  238.     "a"  == "a "
  239.     "a" < "a"
  240.     "a" < "a "
  242.   RETURN
  243.     < 0  a <  b
  244.     = 0  a == b
  245.     > 0  a > b
  246. */
  248. static int my_strnncollsp_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  249.                                const uchar *s, uint slen,
  250.                                const uchar *t, uint tlen)
  251. {
  252.   const uchar *se, *te;
  253.   uint minlen;
  255.   /* extra safety to make sure the lengths are even numbers */
  256.   slen= (slen >> 1) << 1;
  257.   tlen= (tlen >> 1) << 1;
  259.   se= s + slen;
  260.   te= t + tlen;
  262.   for (minlen= min(slen, tlen); minlen; minlen-= 2)
  263.   {
  264.     int s_wc = uni_plane[s[0]] ? (int) uni_plane[s[0]][s[1]].sort :
  265.                                  (((int) s[0]) << 8) + (int) s[1];
  267.     int t_wc = uni_plane[t[0]] ? (int) uni_plane[t[0]][t[1]].sort : 
  268.                                  (((int) t[0]) << 8) + (int) t[1];
  269.     if ( s_wc != t_wc )
  270.       return  s_wc > t_wc ? 1 : -1;
  272.     s+= 2;
  273.     t+= 2;
  274.   }
  276.   if (slen != tlen)
  277.   {
  278.     int swap= 1;
  279.     if (slen < tlen)
  280.     {
  281.       s= t;
  282.       se= te;
  283.       swap= -1;
  284.     }
  286.     for ( ; s < se ; s+= 2)
  287.     {
  288.       if (s[0] || s[1] != ' ')
  289.         return (s[0] == 0 && s[1] < ' ') ? -swap : swap;
  290.     }
  291.   }
  292.   return 0;
  293. }
  296. static int my_strncasecmp_ucs2(CHARSET_INFO *cs,
  297.        const char *s, const char *t,  uint len)
  298. {
  299.   int s_res,t_res;
  300.   my_wc_t s_wc,t_wc;
  301.   const char *se=s+len;
  302.   const char *te=t+len;
  303.   
  304.   while ( s < se && t < te )
  305.   {
  306.     int plane;
  307.     
  308.     s_res=my_ucs2_uni(cs,&s_wc, (const uchar*)s, (const uchar*)se);
  309.     t_res=my_ucs2_uni(cs,&t_wc, (const uchar*)t, (const uchar*)te);
  310.     
  311.     if ( s_res <= 0 || t_res <= 0 )
  312.     {
  313.       /* Incorrect string, compare by char value */
  314.       return ((int)s[0]-(int)t[0]); 
  315.     }
  316.     
  317.     plane=(s_wc>>8) & 0xFF;
  318.     s_wc = uni_plane[plane] ? uni_plane[plane][s_wc & 0xFF].tolower : s_wc;
  320.     plane=(t_wc>>8) & 0xFF;
  321.     t_wc = uni_plane[plane] ? uni_plane[plane][t_wc & 0xFF].tolower : t_wc;
  322.     
  323.     if ( s_wc != t_wc )
  324.       return  ((int) s_wc) - ((int) t_wc);
  325.     
  326.     s+=s_res;
  327.     t+=t_res;
  328.   }
  329.   return (int) ( (se-s) - (te-t) );
  330. }
  333. static int my_strcasecmp_ucs2(CHARSET_INFO *cs, const char *s, const char *t)
  334. {
  335.   uint s_len=strlen(s);
  336.   uint t_len=strlen(t);
  337.   uint len = (s_len > t_len) ? s_len : t_len;
  338.   return  my_strncasecmp_ucs2(cs, s, t, len);
  339. }
  342. static int my_strnxfrm_ucs2(CHARSET_INFO *cs, 
  343. uchar *dst, uint dstlen, const uchar *src, uint srclen)
  344. {
  345.   my_wc_t wc;
  346.   int res;
  347.   int plane;
  348.   uchar *de = dst + dstlen;
  349.   const uchar *se = src + srclen;
  351.   while( src < se && dst < de )
  352.   {
  353.     if ((res=my_ucs2_uni(cs,&wc, src, se))<0)
  354.     {
  355.       break;
  356.     }
  357.     src+=res;
  358.     srclen-=res;
  359.     
  360.     plane=(wc>>8) & 0xFF;
  361.     wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].sort : wc;
  362.     
  363.     if ((res=my_uni_ucs2(cs,wc,dst,de)) <0)
  364.     {
  365.       break;
  366.     }
  367.     dst+=res;
  368.   }
  369.   if (dst < de)
  370.     cs->cset->fill(cs, dst, de - dst, ' ');
  371.   return dstlen;
  372. }
  375. static int my_ismbchar_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  376.                      const char *b __attribute__((unused)),
  377.                      const char *e __attribute__((unused)))
  378. {
  379.   return 2;
  380. }
  383. static int my_mbcharlen_ucs2(CHARSET_INFO *cs  __attribute__((unused)) , 
  384.                       uint c __attribute__((unused)))
  385. {
  386.   return 2;
  387. }
  390. #include <m_string.h>
  391. #include <stdarg.h>
  393. static int my_vsnprintf_ucs2(char *dst, uint n, const char* fmt, va_list ap)
  394. {
  395.   char *start=dst, *end=dst+n-1;
  396.   for (; *fmt ; fmt++)
  397.   {
  398.     if (fmt[0] != '%')
  399.     {
  400.       if (dst == end) /* End of buffer */
  401. break;
  402.       
  403.       *dst++=''; *dst++= *fmt; /* Copy ordinary char */
  404.       continue;
  405.     }
  406.     
  407.     fmt++;
  408.     
  409.     /* Skip if max size is used (to be compatible with printf) */
  410.     while ( (*fmt>='0' && *fmt<='9') || *fmt == '.' || *fmt == '-')
  411.       fmt++;
  412.     
  413.     if (*fmt == 'l')
  414.       fmt++;
  415.     
  416.     if (*fmt == 's') /* String parameter */
  417.     {
  418.       reg2 char *par = va_arg(ap, char *);
  419.       uint plen;
  420.       uint left_len = (uint)(end-dst);
  421.       if (!par) par = (char*)"(null)";
  422.       plen = (uint) strlen(par);
  423.       if (left_len <= plen*2)
  424. plen = left_len/2 - 1;
  426.       for ( ; plen ; plen--, dst+=2, par++)
  427.       {
  428.         dst[0]='';
  429.         dst[1]=par[0];
  430.       }
  431.       continue;
  432.     }
  433.     else if (*fmt == 'd' || *fmt == 'u') /* Integer parameter */
  434.     {
  435.       register int iarg;
  436.       char nbuf[16];
  437.       char *pbuf=nbuf;
  438.       
  439.       if ((uint) (end-dst) < 32)
  440. break;
  441.       iarg = va_arg(ap, int);
  442.       if (*fmt == 'd')
  443. int10_to_str((long) iarg, nbuf, -10);
  444.       else
  445. int10_to_str((long) (uint) iarg,nbuf,10);
  447.       for (; pbuf[0]; pbuf++)
  448.       {
  449.         *dst++='';
  450.         *dst++=*pbuf;
  451.       }
  452.       continue;
  453.     }
  454.     
  455.     /* We come here on '%%', unknown code or too long parameter */
  456.     if (dst == end)
  457.       break;
  458.     *dst++='';
  459.     *dst++='%'; /* % used as % or unknown code */
  460.   }
  461.   
  462.   DBUG_ASSERT(dst <= end);
  463.   *dst=''; /* End of errmessage */
  464.   return (uint) (dst - start);
  465. }
  467. static int my_snprintf_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  468.     char* to, uint n, const char* fmt, ...)
  469. {
  470.   va_list args;
  471.   va_start(args,fmt);
  472.   return my_vsnprintf_ucs2(to, n, fmt, args);
  473. }
  476. long my_strntol_ucs2(CHARSET_INFO *cs,
  477.      const char *nptr, uint l, int base,
  478.      char **endptr, int *err)
  479. {
  480.   int      negative=0;
  481.   int      overflow;
  482.   int      cnv;
  483.   my_wc_t  wc;
  484.   register unsigned int cutlim;
  485.   register uint32 cutoff;
  486.   register uint32 res;
  487.   register const uchar *s= (const uchar*) nptr;
  488.   register const uchar *e= (const uchar*) nptr+l;
  489.   const uchar *save;
  490.   
  491.   *err= 0;
  492.   do
  493.   {
  494.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  495.     {
  496.       switch (wc)
  497.       {
  498.         case ' ' : break;
  499.         case 't': break;
  500.         case '-' : negative= !negative; break;
  501.         case '+' : break;
  502.         default  : goto bs;
  503.       }
  504.     } 
  505.     else /* No more characters or bad multibyte sequence */
  506.     {
  507.       if (endptr !=NULL )
  508.         *endptr = (char*)s;
  509.       err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
  510.       return 0;
  511.     } 
  512.     s+=cnv;
  513.   } while (1);
  514.   
  515. bs:
  517. #ifdef NOT_USED  
  518.   if (base <= 0 || base == 1 || base > 36)
  519.     base = 10;
  520. #endif
  521.   
  522.   overflow = 0;
  523.   res = 0;
  524.   save = s;
  525.   cutoff = ((uint32)~0L) / (uint32) base;
  526.   cutlim = (uint) (((uint32)~0L) % (uint32) base);
  527.   
  528.   do {
  529.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  530.     {
  531.       s+=cnv;
  532.       if ( wc>='0' && wc<='9')
  533.         wc -= '0';
  534.       else if ( wc>='A' && wc<='Z')
  535.         wc = wc - 'A' + 10;
  536.       else if ( wc>='a' && wc<='z')
  537.         wc = wc - 'a' + 10;
  538.       else
  539.         break;
  540.       if ((int)wc >= base)
  541.         break;
  542.       if (res > cutoff || (res == cutoff && wc > cutlim))
  543.         overflow = 1;
  544.       else
  545.       {
  546.         res *= (uint32) base;
  547.         res += wc;
  548.       }
  549.     }
  550.     else if (cnv==MY_CS_ILSEQ)
  551.     {
  552.       if (endptr !=NULL )
  553.         *endptr = (char*)s;
  554.       err[0]=EILSEQ;
  555.       return 0;
  556.     } 
  557.     else
  558.     {
  559.       /* No more characters */
  560.       break;
  561.     }
  562.   } while(1);
  563.   
  564.   if (endptr != NULL)
  565.     *endptr = (char *) s;
  566.   
  567.   if (s == save)
  568.   {
  569.     err[0]=EDOM;
  570.     return 0L;
  571.   }
  572.   
  573.   if (negative)
  574.   {
  575.     if (res > (uint32) INT_MIN32)
  576.       overflow = 1;
  577.   }
  578.   else if (res > INT_MAX32)
  579.     overflow = 1;
  580.   
  581.   if (overflow)
  582.   {
  583.     err[0]=ERANGE;
  584.     return negative ? INT_MIN32 : INT_MAX32;
  585.   }
  586.   
  587.   return (negative ? -((long) res) : (long) res);
  588. }
  591. ulong my_strntoul_ucs2(CHARSET_INFO *cs,
  592.        const char *nptr, uint l, int base, 
  593.        char **endptr, int *err)
  594. {
  595.   int      negative=0;
  596.   int      overflow;
  597.   int      cnv;
  598.   my_wc_t  wc;
  599.   register unsigned int cutlim;
  600.   register uint32 cutoff;
  601.   register uint32 res;
  602.   register const uchar *s= (const uchar*) nptr;
  603.   register const uchar *e= (const uchar*) nptr+l;
  604.   const uchar *save;
  605.   
  606.   *err= 0;
  607.   do
  608.   {
  609.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  610.     {
  611.       switch (wc)
  612.       {
  613.         case ' ' : break;
  614.         case 't': break;
  615.         case '-' : negative= !negative; break;
  616.         case '+' : break;
  617.         default  : goto bs;
  618.       }
  619.     } 
  620.     else /* No more characters or bad multibyte sequence */
  621.     {
  622.       if (endptr !=NULL )
  623.         *endptr = (char*)s;
  624.       err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
  625.       return 0;
  626.     } 
  627.     s+=cnv;
  628.   } while (1);
  629.   
  630. bs:
  632. #ifdef NOT_USED
  633.   if (base <= 0 || base == 1 || base > 36)
  634.     base = 10;
  635. #endif
  637.   overflow = 0;
  638.   res = 0;
  639.   save = s;
  640.   cutoff = ((uint32)~0L) / (uint32) base;
  641.   cutlim = (uint) (((uint32)~0L) % (uint32) base);
  642.   
  643.   do
  644.   {
  645.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  646.     {
  647.       s+=cnv;
  648.       if ( wc>='0' && wc<='9')
  649.         wc -= '0';
  650.       else if ( wc>='A' && wc<='Z')
  651.         wc = wc - 'A' + 10;
  652.       else if ( wc>='a' && wc<='z')
  653.         wc = wc - 'a' + 10;
  654.       else
  655.         break;
  656.       if ((int)wc >= base)
  657.         break;
  658.       if (res > cutoff || (res == cutoff && wc > cutlim))
  659.         overflow = 1;
  660.       else
  661.       {
  662.         res *= (uint32) base;
  663.         res += wc;
  664.       }
  665.     }
  666.     else if (cnv==MY_CS_ILSEQ)
  667.     {
  668.       if (endptr !=NULL )
  669.         *endptr = (char*)s;
  670.       err[0]=EILSEQ;
  671.       return 0;
  672.     } 
  673.     else
  674.     {
  675.       /* No more characters */
  676.       break;
  677.     }
  678.   } while(1);
  679.   
  680.   if (endptr != NULL)
  681.     *endptr = (char *) s;
  682.   
  683.   if (s == save)
  684.   {
  685.     err[0]=EDOM;
  686.     return 0L;
  687.   }
  688.   
  689.   if (overflow)
  690.   {
  691.     err[0]=(ERANGE);
  692.     return (~(uint32) 0);
  693.   }
  694.   
  695.   return (negative ? -((long) res) : (long) res);
  696. }
  700. longlong  my_strntoll_ucs2(CHARSET_INFO *cs,
  701.    const char *nptr, uint l, int base,
  702.    char **endptr, int *err)
  703. {
  704.   int      negative=0;
  705.   int      overflow;
  706.   int      cnv;
  707.   my_wc_t  wc;
  708.   register ulonglong    cutoff;
  709.   register unsigned int cutlim;
  710.   register ulonglong    res;
  711.   register const uchar *s= (const uchar*) nptr;
  712.   register const uchar *e= (const uchar*) nptr+l;
  713.   const uchar *save;
  714.   
  715.   *err= 0;
  716.   do
  717.   {
  718.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  719.     {
  720.       switch (wc)
  721.       {
  722.         case ' ' : break;
  723.         case 't': break;
  724.         case '-' : negative= !negative; break;
  725.         case '+' : break;
  726.         default  : goto bs;
  727.       }
  728.     } 
  729.     else /* No more characters or bad multibyte sequence */
  730.     {
  731.       if (endptr !=NULL )
  732.         *endptr = (char*)s;
  733.       err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
  734.       return 0;
  735.     } 
  736.     s+=cnv;
  737.   } while (1);
  738.   
  739. bs:
  741. #ifdef NOT_USED  
  742.   if (base <= 0 || base == 1 || base > 36)
  743.     base = 10;
  744. #endif
  746.   overflow = 0;
  747.   res = 0;
  748.   save = s;
  749.   cutoff = (~(ulonglong) 0) / (unsigned long int) base;
  750.   cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
  752.   do {
  753.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  754.     {
  755.       s+=cnv;
  756.       if ( wc>='0' && wc<='9')
  757.         wc -= '0';
  758.       else if ( wc>='A' && wc<='Z')
  759.         wc = wc - 'A' + 10;
  760.       else if ( wc>='a' && wc<='z')
  761.         wc = wc - 'a' + 10;
  762.       else
  763.         break;
  764.       if ((int)wc >= base)
  765.         break;
  766.       if (res > cutoff || (res == cutoff && wc > cutlim))
  767.         overflow = 1;
  768.       else
  769.       {
  770.         res *= (ulonglong) base;
  771.         res += wc;
  772.       }
  773.     }
  774.     else if (cnv==MY_CS_ILSEQ)
  775.     {
  776.       if (endptr !=NULL )
  777.         *endptr = (char*)s;
  778.       err[0]=EILSEQ;
  779.       return 0;
  780.     } 
  781.     else
  782.     {
  783.       /* No more characters */
  784.       break;
  785.     }
  786.   } while(1);
  787.   
  788.   if (endptr != NULL)
  789.     *endptr = (char *) s;
  790.   
  791.   if (s == save)
  792.   {
  793.     err[0]=EDOM;
  794.     return 0L;
  795.   }
  796.   
  797.   if (negative)
  798.   {
  799.     if (res  > (ulonglong) LONGLONG_MIN)
  800.       overflow = 1;
  801.   }
  802.   else if (res > (ulonglong) LONGLONG_MAX)
  803.     overflow = 1;
  804.   
  805.   if (overflow)
  806.   {
  807.     err[0]=ERANGE;
  808.     return negative ? LONGLONG_MIN : LONGLONG_MAX;
  809.   }
  810.   
  811.   return (negative ? -((longlong)res) : (longlong)res);
  812. }
  817. ulonglong  my_strntoull_ucs2(CHARSET_INFO *cs,
  818.    const char *nptr, uint l, int base,
  819.    char **endptr, int *err)
  820. {
  821.   int      negative=0;
  822.   int      overflow;
  823.   int      cnv;
  824.   my_wc_t  wc;
  825.   register ulonglong    cutoff;
  826.   register unsigned int cutlim;
  827.   register ulonglong    res;
  828.   register const uchar *s= (const uchar*) nptr;
  829.   register const uchar *e= (const uchar*) nptr+l;
  830.   const uchar *save;
  831.   
  832.   *err= 0;
  833.   do
  834.   {
  835.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  836.     {
  837.       switch (wc)
  838.       {
  839.         case ' ' : break;
  840.         case 't': break;
  841.         case '-' : negative= !negative; break;
  842.         case '+' : break;
  843.         default  : goto bs;
  844.       }
  845.     } 
  846.     else /* No more characters or bad multibyte sequence */
  847.     {
  848.       if (endptr !=NULL )
  849.         *endptr = (char*)s;
  850.       err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
  851.       return 0;
  852.     } 
  853.     s+=cnv;
  854.   } while (1);
  855.   
  856. bs:
  857.   
  858. #ifdef NOT_USED
  859.   if (base <= 0 || base == 1 || base > 36)
  860.     base = 10;
  861. #endif
  863.   overflow = 0;
  864.   res = 0;
  865.   save = s;
  866.   cutoff = (~(ulonglong) 0) / (unsigned long int) base;
  867.   cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
  869.   do
  870.   {
  871.     if ((cnv=cs->cset->mb_wc(cs,&wc,s,e))>0)
  872.     {
  873.       s+=cnv;
  874.       if ( wc>='0' && wc<='9')
  875.         wc -= '0';
  876.       else if ( wc>='A' && wc<='Z')
  877.         wc = wc - 'A' + 10;
  878.       else if ( wc>='a' && wc<='z')
  879.         wc = wc - 'a' + 10;
  880.       else
  881.         break;
  882.       if ((int)wc >= base)
  883.         break;
  884.       if (res > cutoff || (res == cutoff && wc > cutlim))
  885.         overflow = 1;
  886.       else
  887.       {
  888.         res *= (ulonglong) base;
  889.         res += wc;
  890.       }
  891.     }
  892.     else if (cnv==MY_CS_ILSEQ)
  893.     {
  894.       if (endptr !=NULL )
  895.         *endptr = (char*)s;
  896.       err[0]= EILSEQ;
  897.       return 0;
  898.     } 
  899.     else
  900.     {
  901.       /* No more characters */
  902.       break;
  903.     }
  904.   } while(1);
  905.   
  906.   if (endptr != NULL)
  907.     *endptr = (char *) s;
  908.   
  909.   if (s == save)
  910.   {
  911.     err[0]= EDOM;
  912.     return 0L;
  913.   }
  914.   
  915.   if (overflow)
  916.   {
  917.     err[0]= ERANGE;
  918.     return (~(ulonglong) 0);
  919.   }
  921.   return (negative ? -((longlong) res) : (longlong) res);
  922. }
  924. double      my_strntod_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  925.    char *nptr, uint length, 
  926.    char **endptr, int *err)
  927. {
  928.   char     buf[256];
  929.   double   res;
  930.   register char *b=buf;
  931.   register const uchar *s= (const uchar*) nptr;
  932.   register const uchar *end;
  933.   my_wc_t  wc;
  934.   int      cnv;
  936.   *err= 0;
  937.   /* Cut too long strings */
  938.   if (length >= sizeof(buf))
  939.     length= sizeof(buf)-1;
  940.   end= s+length;
  942.   while ((cnv=cs->cset->mb_wc(cs,&wc,s,end)) > 0)
  943.   {
  944.     s+=cnv;
  945.     if (wc > (int) (uchar) 'e' || !wc)
  946.       break; /* Can't be part of double */
  947.     *b++= (char) wc;
  948.   }
  950.   *endptr= b;
  951.   res= my_strtod(buf, endptr, err);
  952.   *endptr= nptr + (uint) (*endptr- buf);
  953.   return res;
  954. }
  957. /*
  958.   This is a fast version optimized for the case of radix 10 / -10
  959. */
  961. int my_l10tostr_ucs2(CHARSET_INFO *cs,
  962.      char *dst, uint len, int radix, long int val)
  963. {
  964.   char buffer[66];
  965.   register char *p, *db, *de;
  966.   long int new_val;
  967.   int  sl=0;
  968.   
  969.   p = &buffer[sizeof(buffer)-1];
  970.   *p='';
  971.   
  972.   if (radix < 0)
  973.   {
  974.     if (val < 0)
  975.     {
  976.       sl   = 1;
  977.       val  = -val;
  978.     }
  979.   }
  980.   
  981.   new_val = (long) ((unsigned long int) val / 10);
  982.   *--p    = '0'+ (char) ((unsigned long int) val - (unsigned long) new_val * 10);
  983.   val     = new_val;
  984.   
  985.   while (val != 0)
  986.   {
  987.     new_val=val/10;
  988.     *--p = '0' + (char) (val-new_val*10);
  989.     val= new_val;
  990.   }
  991.   
  992.   if (sl)
  993.   {
  994.     *--p='-';
  995.   }
  996.   
  997.   for ( db=dst, de=dst+len ; (dst<de) && *p ; p++)
  998.   {
  999.     int cnvres=cs->cset->wc_mb(cs,(my_wc_t)p[0],(uchar*) dst, (uchar*) de);
  1000.     if (cnvres>0)
  1001.       dst+=cnvres;
  1002.     else
  1003.       break;
  1004.   }
  1005.   return (int) (dst-db);
  1006. }
  1008. int my_ll10tostr_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1009.       char *dst, uint len, int radix, longlong val)
  1010. {
  1011.   char buffer[65];
  1012.   register char *p, *db, *de;
  1013.   long long_val;
  1014.   int  sl=0;
  1015.   
  1016.   if (radix < 0)
  1017.   {
  1018.     if (val < 0)
  1019.     {
  1020.       sl=1;
  1021.       val = -val;
  1022.     }
  1023.   }
  1024.   
  1025.   p = &buffer[sizeof(buffer)-1];
  1026.   *p='';
  1027.   
  1028.   if (val == 0)
  1029.   {
  1030.     *--p='0';
  1031.     goto cnv;
  1032.   }
  1033.   
  1034.   while ((ulonglong) val > (ulonglong) LONG_MAX)
  1035.   {
  1036.     ulonglong quo=(ulonglong) val/(uint) 10;
  1037.     uint rem= (uint) (val- quo* (uint) 10);
  1038.     *--p = '0' + rem;
  1039.     val= quo;
  1040.   }
  1041.   
  1042.   long_val= (long) val;
  1043.   while (long_val != 0)
  1044.   {
  1045.     long quo= long_val/10;
  1046.     *--p = (char) ('0' + (long_val - quo*10));
  1047.     long_val= quo;
  1048.   }
  1049.   
  1050. cnv:
  1051.   if (sl)
  1052.   {
  1053.     *--p='-';
  1054.   }
  1055.   
  1056.   for ( db=dst, de=dst+len ; (dst<de) && *p ; p++)
  1057.   {
  1058.     int cnvres=cs->cset->wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
  1059.     if (cnvres>0)
  1060.       dst+=cnvres;
  1061.     else
  1062.       break;
  1063.   }
  1064.   return (int) (dst-db);
  1065. }
  1068. #undef  ULONGLONG_MAX
  1069. #define ULONGLONG_MAX (~(ulonglong) 0)
  1070. #define MAX_NEGATIVE_NUMBER ((ulonglong) LL(0x8000000000000000))
  1071. #define INIT_CNT  9
  1072. #define LFACTOR   ULL(1000000000)
  1073. #define LFACTOR1  ULL(10000000000)
  1074. #define LFACTOR2  ULL(100000000000)
  1076. static unsigned long lfactor[9]=
  1077. {
  1078.   1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L
  1079. };
  1082. longlong my_strtoll10_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1083.                            const char *nptr, char **endptr, int *error)
  1084. {
  1085.   const char *s, *end, *start, *n_end, *true_end;
  1086.   unsigned char c;
  1087.   unsigned long i, j, k;
  1088.   ulonglong li;
  1089.   int negative;
  1090.   ulong cutoff, cutoff2, cutoff3;
  1092.   s= nptr;
  1093.   /* If fixed length string */
  1094.   if (endptr)
  1095.   {
  1096.     /* Make sure string length is even */
  1097.     end= s + ((*endptr - s) / 2) * 2;
  1098.     while (s < end && !s[0] && (s[1] == ' ' || s[1] == 't'))
  1099.       s+= 2;
  1100.     if (s == end)
  1101.       goto no_conv;
  1102.   }
  1103.   else
  1104.   {
  1105.      /* We don't support null terminated strings in UCS2 */
  1106.      goto no_conv;
  1107.   }
  1109.   /* Check for a sign. */
  1110.   negative= 0;
  1111.   if (!s[0] && s[1] == '-')
  1112.   {
  1113.     *error= -1; /* Mark as negative number */
  1114.     negative= 1;
  1115.     s+= 2;
  1116.     if (s == end)
  1117.       goto no_conv;
  1118.     cutoff=  MAX_NEGATIVE_NUMBER / LFACTOR2;
  1119.     cutoff2= (MAX_NEGATIVE_NUMBER % LFACTOR2) / 100;
  1120.     cutoff3=  MAX_NEGATIVE_NUMBER % 100;
  1121.   }
  1122.   else
  1123.   {
  1124.     *error= 0;
  1125.     if (!s[0] && s[1] == '+')
  1126.     {
  1127.       s+= 2;
  1128.       if (s == end)
  1129. goto no_conv;
  1130.     }
  1131.     cutoff=  ULONGLONG_MAX / LFACTOR2;
  1132.     cutoff2= ULONGLONG_MAX % LFACTOR2 / 100;
  1133.     cutoff3=  ULONGLONG_MAX % 100;
  1134.   }
  1136.   /* Handle case where we have a lot of pre-zero */
  1137.   if (!s[0] && s[1] == '0')
  1138.   {
  1139.     i= 0;
  1140.     do
  1141.     {
  1142.       s+= 2;
  1143.       if (s == end)
  1144. goto end_i; /* Return 0 */
  1145.     }
  1146.     while (!s[0] && s[1] == '0');
  1147.     n_end= s + 2 * INIT_CNT;
  1148.   }
  1149.   else
  1150.   {
  1151.     /* Read first digit to check that it's a valid number */
  1152.     if (s[0] || (c= (s[1]-'0')) > 9)
  1153.       goto no_conv;
  1154.     i= c;
  1155.     s+= 2;
  1156.     n_end= s + 2 * (INIT_CNT-1);
  1157.   }
  1159.   /* Handle first 9 digits and store them in i */
  1160.   if (n_end > end)
  1161.     n_end= end;
  1162.   for (; s != n_end ; s+= 2)
  1163.   {
  1164.     if (s[0] || (c= (s[1]-'0')) > 9)
  1165.       goto end_i;
  1166.     i= i*10+c;
  1167.   }
  1168.   if (s == end)
  1169.     goto end_i;
  1171.   /* Handle next 9 digits and store them in j */
  1172.   j= 0;
  1173.   start= s; /* Used to know how much to shift i */
  1174.   n_end= true_end= s + 2 * INIT_CNT;
  1175.   if (n_end > end)
  1176.     n_end= end;
  1177.   do
  1178.   {
  1179.     if (s[0] || (c= (s[1]-'0')) > 9)
  1180.       goto end_i_and_j;
  1181.     j= j*10+c;
  1182.     s+= 2;
  1183.   } while (s != n_end);
  1184.   if (s == end)
  1185.   {
  1186.     if (s != true_end)
  1187.       goto end_i_and_j;
  1188.     goto end3;
  1189.   }
  1190.   if (s[0] || (c= (s[1]-'0')) > 9)
  1191.     goto end3;
  1193.   /* Handle the next 1 or 2 digits and store them in k */
  1194.   k=c;
  1195.   s+= 2;
  1196.   if (s == end || s[0] || (c= (s[1]-'0')) > 9)
  1197.     goto end4;
  1198.   k= k*10+c;
  1199.   s+= 2;
  1200.   *endptr= (char*) s;
  1202.   /* number string should have ended here */
  1203.   if (s != end && !s[0] && (c= (s[1]-'0')) <= 9)
  1204.     goto overflow;
  1206.   /* Check that we didn't get an overflow with the last digit */
  1207.   if (i > cutoff || (i == cutoff && ((j > cutoff2 || j == cutoff2) &&
  1208.                                      k > cutoff3)))
  1209.     goto overflow;
  1210.   li=i*LFACTOR2+ (ulonglong) j*100 + k;
  1211.   return (longlong) li;
  1213. overflow: /* *endptr is set here */
  1214.   *error= MY_ERRNO_ERANGE;
  1215.   return negative ? LONGLONG_MIN : (longlong) ULONGLONG_MAX;
  1217. end_i:
  1218.   *endptr= (char*) s;
  1219.   return (negative ? ((longlong) -(long) i) : (longlong) i);
  1221. end_i_and_j:
  1222.   li= (ulonglong) i * lfactor[(uint) (s-start) / 2] + j;
  1223.   *endptr= (char*) s;
  1224.   return (negative ? -((longlong) li) : (longlong) li);
  1226. end3:
  1227.   li=(ulonglong) i*LFACTOR+ (ulonglong) j;
  1228.   *endptr= (char*) s;
  1229.   return (negative ? -((longlong) li) : (longlong) li);
  1231. end4:
  1232.   li=(ulonglong) i*LFACTOR1+ (ulonglong) j * 10 + k;
  1233.   *endptr= (char*) s;
  1234.   if (negative)
  1235.   {
  1236.    if (li > MAX_NEGATIVE_NUMBER)
  1237.      goto overflow;
  1238.    return -((longlong) li);
  1239.   }
  1240.   return (longlong) li;
  1242. no_conv:
  1243.   /* There was no number to convert.  */
  1244.   *error= MY_ERRNO_EDOM;
  1245.   *endptr= (char *) nptr;
  1246.   return 0;
  1247. }
  1250. static
  1251. uint my_numchars_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1252.       const char *b, const char *e)
  1253. {
  1254.   return (uint) (e-b)/2;
  1255. }
  1258. static
  1259. uint my_charpos_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1260.      const char *b  __attribute__((unused)),
  1261.      const char *e  __attribute__((unused)),
  1262.      uint pos)
  1263. {
  1264.   uint string_length= (uint) (e - b);
  1265.   return pos > string_length ? string_length + 2 : pos * 2;
  1266. }
  1269. static
  1270. uint my_well_formed_len_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1271.                              const char *b, const char *e,
  1272.                              uint nchars, int *error)
  1273. {
  1274.   /* Ensure string length is dividable with 2 */
  1275.   uint nbytes= ((uint) (e-b)) & ~(uint) 1;
  1276.   *error= 0;
  1277.   nchars*= 2;
  1278.   return min(nbytes, nchars);
  1279. }
  1282. static
  1283. void my_fill_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1284.    char *s, uint l, int fill)
  1285. {
  1286.   for ( ; l >= 2; s[0]= 0, s[1]= fill, s+=2, l-=2);
  1287. }
  1290. static
  1291. uint my_lengthsp_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1292.       const char *ptr, uint length)
  1293. {
  1294.   const char *end= ptr+length;
  1295.   while (end > ptr+1 && end[-1] == ' ' && end[-2] == '')
  1296.     end-=2;
  1297.   return (uint) (end-ptr);
  1298. }
  1301. static
  1302. int my_wildcmp_ucs2_ci(CHARSET_INFO *cs,
  1303.     const char *str,const char *str_end,
  1304.     const char *wildstr,const char *wildend,
  1305.     int escape, int w_one, int w_many)
  1306. {
  1307.   return my_wildcmp_unicode(cs,str,str_end,wildstr,wildend,
  1308.                             escape,w_one,w_many,uni_plane); 
  1309. }
  1312. static
  1313. int my_wildcmp_ucs2_bin(CHARSET_INFO *cs,
  1314.     const char *str,const char *str_end,
  1315.     const char *wildstr,const char *wildend,
  1316.     int escape, int w_one, int w_many)
  1317. {
  1318.   return my_wildcmp_unicode(cs,str,str_end,wildstr,wildend,
  1319.                             escape,w_one,w_many,NULL); 
  1320. }
  1323. static
  1324. int my_strnncoll_ucs2_bin(CHARSET_INFO *cs, 
  1325.                           const uchar *s, uint slen,
  1326.                           const uchar *t, uint tlen,
  1327.                           my_bool t_is_prefix)
  1328. {
  1329.   int s_res,t_res;
  1330.   my_wc_t s_wc,t_wc;
  1331.   const uchar *se=s+slen;
  1332.   const uchar *te=t+tlen;
  1334.   while ( s < se && t < te )
  1335.   {
  1336.     s_res=my_ucs2_uni(cs,&s_wc, s, se);
  1337.     t_res=my_ucs2_uni(cs,&t_wc, t, te);
  1338.     
  1339.     if ( s_res <= 0 || t_res <= 0 )
  1340.     {
  1341.       /* Incorrect string, compare by char value */
  1342.       return ((int)s[0]-(int)t[0]); 
  1343.     }
  1344.     if ( s_wc != t_wc )
  1345.     {
  1346.       return  s_wc > t_wc ? 1 : -1;
  1347.     }
  1348.     
  1349.     s+=s_res;
  1350.     t+=t_res;
  1351.   }
  1352.   return t_is_prefix ? (int) (t - te) : (int) ((se-s) - (te-t));
  1353. }
  1355. static int my_strnncollsp_ucs2_bin(CHARSET_INFO *cs, 
  1356.                                    const uchar *s, uint slen, 
  1357.                                    const uchar *t, uint tlen)
  1358. {
  1359.   return my_strnncoll_ucs2_bin(cs,s,slen,t,tlen,0);
  1360. }
  1363. static
  1364. int my_strcasecmp_ucs2_bin(CHARSET_INFO *cs, const char *s, const char *t)
  1365. {
  1366.   uint s_len=strlen(s);
  1367.   uint t_len=strlen(t);
  1368.   uint len = (s_len > t_len) ? s_len : t_len;
  1369.   return  my_strncasecmp_ucs2(cs, s, t, len);
  1370. }
  1373. static
  1374. int my_strnxfrm_ucs2_bin(CHARSET_INFO *cs __attribute__((unused)),
  1375.  uchar *dst, uint dstlen,
  1376.  const uchar *src, uint srclen)
  1377. {
  1378.   if (dst != src)
  1379.     memcpy(dst,src,srclen= min(dstlen,srclen));
  1380.   if (dstlen > srclen)
  1381.     cs->cset->fill(cs, dst + srclen, dstlen - srclen, ' ');
  1382.   return dstlen;
  1383. }
  1386. static
  1387. void my_hash_sort_ucs2_bin(CHARSET_INFO *cs __attribute__((unused)),
  1388.    const uchar *key, uint len,ulong *nr1, ulong *nr2)
  1389. {
  1390.   const uchar *pos = key;
  1391.   
  1392.   key+= len;
  1393.   
  1394.   for (; pos < (uchar*) key ; pos++)
  1395.   {
  1396.     nr1[0]^=(ulong) ((((uint) nr1[0] & 63)+nr2[0]) * 
  1397.      ((uint)*pos)) + (nr1[0] << 8);
  1398.     nr2[0]+=3;
  1399.   }
  1400. }
  1402. /*
  1403. ** Calculate min_str and max_str that ranges a LIKE string.
  1404. ** Arguments:
  1405. ** ptr Pointer to LIKE string.
  1406. ** ptr_length Length of LIKE string.
  1407. ** escape Escape character in LIKE.  (Normally '').
  1408. ** All escape characters should be removed from min_str and max_str
  1409. ** res_length Length of min_str and max_str.
  1410. ** min_str Smallest case sensitive string that ranges LIKE.
  1411. ** Should be space padded to res_length.
  1412. ** max_str Largest case sensitive string that ranges LIKE.
  1413. ** Normally padded with the biggest character sort value.
  1414. **
  1415. ** The function should return 0 if ok and 1 if the LIKE string can't be
  1416. ** optimized !
  1417. */
  1419. my_bool my_like_range_ucs2(CHARSET_INFO *cs,
  1420.    const char *ptr,uint ptr_length,
  1421.    pbool escape, pbool w_one, pbool w_many,
  1422.    uint res_length,
  1423.    char *min_str,char *max_str,
  1424.    uint *min_length,uint *max_length)
  1425. {
  1426.   const char *end=ptr+ptr_length;
  1427.   char *min_org=min_str;
  1428.   char *min_end=min_str+res_length;
  1429.   uint charlen= res_length / cs->mbmaxlen;
  1430.   
  1431.   for ( ; ptr + 1 < end && min_str + 1 < min_end && charlen > 0
  1432.         ; ptr+=2, charlen--)
  1433.   {
  1434.     if (ptr[0] == '' && ptr[1] == escape && ptr + 1 < end)
  1435.     {
  1436.       ptr+=2; /* Skip escape */
  1437.       *min_str++= *max_str++ = ptr[0];
  1438.       *min_str++= *max_str++ = ptr[1];
  1439.       continue;
  1440.     }
  1441.     if (ptr[0] == '' && ptr[1] == w_one) /* '_' in SQL */
  1442.     {
  1443.       *min_str++= (char) (cs->min_sort_char >> 8);
  1444.       *min_str++= (char) (cs->min_sort_char & 255);
  1445.       *max_str++= (char) (cs->max_sort_char >> 8);
  1446.       *max_str++= (char) (cs->max_sort_char & 255);
  1447.       continue;
  1448.     }
  1449.     if (ptr[0] == '' && ptr[1] == w_many) /* '%' in SQL */
  1450.     {
  1451.       *min_length= (uint) (min_str - min_org);
  1452.       *max_length=res_length;
  1453.       do {
  1454.         *min_str++ = 0;
  1455. *min_str++ = 0;
  1456. *max_str++ = (char) (cs->max_sort_char >> 8);
  1457. *max_str++ = (char) (cs->max_sort_char & 255);
  1458.       } while (min_str + 1 < min_end);
  1459.       return 0;
  1460.     }
  1461.     *min_str++= *max_str++ = ptr[0];
  1462.     *min_str++= *max_str++ = ptr[1];
  1463.   }
  1464.   *min_length= *max_length = (uint) (min_str - min_org);
  1466.   /* Temporary fix for handling w_one at end of string (key compression) */
  1467.   {
  1468.     char *tmp;
  1469.     for (tmp= min_str ; tmp-1 > min_org && tmp[-1] == '' && tmp[-2]=='';)
  1470.     {
  1471.       *--tmp=' ';
  1472.       *--tmp='';
  1473.     }
  1474.   }
  1475.   
  1476.   while (min_str + 1 < min_end)
  1477.   {
  1478.     *min_str++ = *max_str++ = '';
  1479.     *min_str++ = *max_str++ = ' '; /* Because if key compression */
  1480.   }
  1481.   return 0;
  1482. }
  1485. ulong my_scan_ucs2(CHARSET_INFO *cs __attribute__((unused)),
  1486.                    const char *str, const char *end, int sequence_type)
  1487. {
  1488.   const char *str0= str;
  1489.   end--; /* for easier loop condition, because of two bytes per character */
  1490.   
  1491.   switch (sequence_type)
  1492.   {
  1493.   case MY_SEQ_SPACES:
  1494.     for ( ; str < end; str+= 2)
  1495.     {
  1496.       if (str[0] != '' || str[1] != ' ')
  1497.         break;
  1498.     }
  1499.     return (ulong) (str - str0);
  1500.   default:
  1501.     return 0;
  1502.   }
  1503. }
  1507. static MY_COLLATION_HANDLER my_collation_ucs2_general_ci_handler =
  1508. {
  1509.     NULL, /* init */
  1510.     my_strnncoll_ucs2,
  1511.     my_strnncollsp_ucs2,
  1512.     my_strnxfrm_ucs2,
  1513.     my_like_range_ucs2,
  1514.     my_wildcmp_ucs2_ci,
  1515.     my_strcasecmp_ucs2,
  1516.     my_instr_mb,
  1517.     my_hash_sort_ucs2
  1518. };
  1521. static MY_COLLATION_HANDLER my_collation_ucs2_bin_handler =
  1522. {
  1523.     NULL, /* init */
  1524.     my_strnncoll_ucs2_bin,
  1525.     my_strnncollsp_ucs2_bin,
  1526.     my_strnxfrm_ucs2_bin,
  1527.     my_like_range_simple,
  1528.     my_wildcmp_ucs2_bin,
  1529.     my_strcasecmp_ucs2_bin,
  1530.     my_instr_mb,
  1531.     my_hash_sort_ucs2_bin
  1532. };
  1535. MY_CHARSET_HANDLER my_charset_ucs2_handler=
  1536. {
  1537.     NULL, /* init */
  1538.     my_ismbchar_ucs2, /* ismbchar     */
  1539.     my_mbcharlen_ucs2, /* mbcharlen    */
  1540.     my_numchars_ucs2,
  1541.     my_charpos_ucs2,
  1542.     my_well_formed_len_ucs2,
  1543.     my_lengthsp_ucs2,
  1544.     my_numcells_mb,
  1545.     my_ucs2_uni, /* mb_wc        */
  1546.     my_uni_ucs2, /* wc_mb        */
  1547.     my_caseup_str_ucs2,
  1548.     my_casedn_str_ucs2,
  1549.     my_caseup_ucs2,
  1550.     my_casedn_ucs2,
  1551.     my_snprintf_ucs2,
  1552.     my_l10tostr_ucs2,
  1553.     my_ll10tostr_ucs2,
  1554.     my_fill_ucs2,
  1555.     my_strntol_ucs2,
  1556.     my_strntoul_ucs2,
  1557.     my_strntoll_ucs2,
  1558.     my_strntoull_ucs2,
  1559.     my_strntod_ucs2,
  1560.     my_strtoll10_ucs2,
  1561.     my_scan_ucs2
  1562. };
  1565. CHARSET_INFO my_charset_ucs2_general_ci=
  1566. {
  1567.     35,0,0, /* number       */
  1568.     MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE,
  1569.     "ucs2", /* cs name    */
  1570.     "ucs2_general_ci", /* name         */
  1571.     "", /* comment      */
  1572.     NULL, /* tailoring    */
  1573.     ctype_ucs2, /* ctype        */
  1574.     to_lower_ucs2, /* to_lower     */
  1575.     to_upper_ucs2, /* to_upper     */
  1576.     to_upper_ucs2, /* sort_order   */
  1577.     NULL, /* contractions */
  1578.     NULL, /* sort_order_big*/
  1579.     NULL, /* tab_to_uni   */
  1580.     NULL, /* tab_from_uni */
  1581.     NULL, /* state_map    */
  1582.     NULL, /* ident_map    */
  1583.     1, /* strxfrm_multiply */
  1584.     2, /* mbminlen     */
  1585.     2, /* mbmaxlen     */
  1586.     0, /* min_sort_char */
  1587.     0xFFFF, /* max_sort_char */
  1588.     0,                  /* escape_with_backslash_is_dangerous */
  1589.     &my_charset_ucs2_handler,
  1590.     &my_collation_ucs2_general_ci_handler
  1591. };
  1593. CHARSET_INFO my_charset_ucs2_bin=
  1594. {
  1595.     90,0,0, /* number       */
  1596.     MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_UNICODE,
  1597.     "ucs2", /* cs name    */
  1598.     "ucs2_bin", /* name         */
  1599.     "", /* comment      */
  1600.     NULL, /* tailoring    */
  1601.     ctype_ucs2, /* ctype        */
  1602.     to_lower_ucs2, /* to_lower     */
  1603.     to_upper_ucs2, /* to_upper     */
  1604.     NULL, /* sort_order   */
  1605.     NULL, /* contractions */
  1606.     NULL, /* sort_order_big*/
  1607.     NULL, /* tab_to_uni   */
  1608.     NULL, /* tab_from_uni */
  1609.     NULL, /* state_map    */
  1610.     NULL, /* ident_map    */
  1611.     1, /* strxfrm_multiply */
  1612.     2, /* mbminlen     */
  1613.     2, /* mbmaxlen     */
  1614.     0, /* min_sort_char */
  1615.     0xFFFF, /* max_sort_char */
  1616.     0,                  /* escape_with_backslash_is_dangerous */
  1617.     &my_charset_ucs2_handler,
  1618.     &my_collation_ucs2_bin_handler
  1619. };
  1622. #endif