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

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

MySQL数据库

开发平台：

Visual C++

ctype-simple.c：源码内容
  1. /* Copyright (C) 2002 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program 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
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <my_global.h>
  18. #include "m_string.h"
  19. #include "m_ctype.h"
  20. #include <errno.h>
  22. #include "stdarg.h"
  24. /*
  25.   Converts a string into its sort key.
  26.   
  27.   SYNOPSIS
  28.      my_strnxfrm_xxx()
  29.      
  30.   IMPLEMENTATION
  31.      
  32.      The my_strxfrm_xxx() function transforms a string pointed to by
  33.      'src' with length 'srclen' according to the charset+collation 
  34.      pair 'cs' and copies the result key into 'dest'.
  35.      
  36.      Comparing two strings using memcmp() after my_strnxfrm_xxx()
  37.      is equal to comparing two original strings with my_strnncollsp_xxx().
  38.      
  39.      Not more than 'dstlen' bytes are written into 'dst'.
  40.      To garantee that the whole string is transformed, 'dstlen' must be
  41.      at least srclen*cs->strnxfrm_multiply bytes long. Otherwise,
  42.      consequent memcmp() may return a non-accurate result.
  43.      
  44.      If the source string is too short to fill whole 'dstlen' bytes,
  45.      then the 'dest' string is padded up to 'dstlen', ensuring that:
  46.      
  47.        "a"  == "a "
  48.        "a" < "a"
  49.        "a" < "a "
  50.      
  51.      my_strnxfrm_simple() is implemented for 8bit charsets and
  52.      simple collations with one-to-one string->key transformation.
  53.      
  54.      See also implementations for various charsets/collations in  
  55.      other ctype-xxx.c files.
  56.      
  57.   RETURN
  58.   
  59.     Target len 'dstlen'.
  60.   
  61. */
  64. int my_strnxfrm_simple(CHARSET_INFO * cs, 
  65.                        uchar *dest, uint len,
  66.                        const uchar *src, uint srclen)
  67. {
  68.   uchar *map= cs->sort_order;
  69.   uint dstlen= len;
  70.   set_if_smaller(len, srclen);
  71.   if (dest != src)
  72.   {
  73.     const uchar *end;
  74.     for ( end=src+len; src < end ;  )
  75.       *dest++= map[*src++];
  76.   }
  77.   else
  78.   {
  79.     const uchar *end;
  80.     for ( end=dest+len; dest < end ; dest++)
  81.       *dest= (char) map[(uchar) *dest];
  82.   }
  83.   if (dstlen > len)
  84.     bfill(dest, dstlen - len, ' ');
  85.   return dstlen;
  86. }
  88. int my_strnncoll_simple(CHARSET_INFO * cs, const uchar *s, uint slen, 
  89.                         const uchar *t, uint tlen,
  90.                         my_bool t_is_prefix)
  91. {
  92.   int len = ( slen > tlen ) ? tlen : slen;
  93.   uchar *map= cs->sort_order;
  94.   if (t_is_prefix && slen > tlen)
  95.     slen=tlen;
  96.   while (len--)
  97.   {
  98.     if (map[*s++] != map[*t++])
  99.       return ((int) map[s[-1]] - (int) map[t[-1]]);
  100.   }
  101.   return (int) (slen - tlen);
  102. }
  105. /*
  106.   Compare strings, discarding end space
  108.   SYNOPSIS
  109.     my_strnncollsp_simple()
  110.     cs character set handler
  111.     a First string to compare
  112.     a_length Length of 'a'
  113.     b Second string to compare
  114.     b_length Length of 'b'
  116.   IMPLEMENTATION
  117.     If one string is shorter as the other, then we space extend the other
  118.     so that the strings have equal length.
  120.     This will ensure that the following things hold:
  122.     "a"  == "a "
  123.     "a" < "a"
  124.     "a" < "a "
  126.   RETURN
  127.     < 0  a <  b
  128.     = 0  a == b
  129.     > 0  a > b
  130. */
  132. int my_strnncollsp_simple(CHARSET_INFO * cs, const uchar *a, uint a_length, 
  133.   const uchar *b, uint b_length)
  134. {
  135.   const uchar *map= cs->sort_order, *end;
  136.   uint length;
  138.   end= a + (length= min(a_length, b_length));
  139.   while (a < end)
  140.   {
  141.     if (map[*a++] != map[*b++])
  142.       return ((int) map[a[-1]] - (int) map[b[-1]]);
  143.   }
  144.   if (a_length != b_length)
  145.   {
  146.     int swap= 1;
  147.     /*
  148.       Check the next not space character of the longer key. If it's < ' ',
  149.       then it's smaller than the other key.
  150.     */
  151.     if (a_length < b_length)
  152.     {
  153.       /* put shorter key in s */
  154.       a_length= b_length;
  155.       a= b;
  156.       swap= -1;                                 /* swap sign of result */
  157.     }
  158.     for (end= a + a_length-length; a < end ; a++)
  159.     {
  160.       if (*a != ' ')
  161. return (*a < ' ') ? -swap : swap;
  162.     }
  163.   }
  164.   return 0;
  165. }
  168. void my_caseup_str_8bit(CHARSET_INFO * cs,char *str)
  169. {
  170.   register uchar *map=cs->to_upper;
  171.   while ((*str = (char) map[(uchar) *str]) != 0)
  172.     str++;
  173. }
  175. void my_casedn_str_8bit(CHARSET_INFO * cs,char *str)
  176. {
  177.   register uchar *map=cs->to_lower;
  178.   while ((*str = (char) map[(uchar)*str]) != 0)
  179.     str++;
  180. }
  182. void my_caseup_8bit(CHARSET_INFO * cs, char *str, uint length)
  183. {
  184.   register uchar *map=cs->to_upper;
  185.   for ( ; length>0 ; length--, str++)
  186.     *str= (char) map[(uchar)*str];
  187. }
  189. void my_casedn_8bit(CHARSET_INFO * cs, char *str, uint length)
  190. {
  191.   register uchar *map=cs->to_lower;
  192.   for ( ; length>0 ; length--, str++)
  193.     *str= (char) map[(uchar) *str];
  194. }
  196. int my_strcasecmp_8bit(CHARSET_INFO * cs,const char *s, const char *t)
  197. {
  198.   register uchar *map=cs->to_upper;
  199.   while (map[(uchar) *s] == map[(uchar) *t++])
  200.     if (!*s++) return 0;
  201.   return ((int) map[(uchar) s[0]] - (int) map[(uchar) t[-1]]);
  202. }
  205. int my_mb_wc_8bit(CHARSET_INFO *cs,my_wc_t *wc,
  206.   const unsigned char *str,
  207.   const unsigned char *end __attribute__((unused)))
  208. {
  209.   if (str >= end)
  210.     return MY_CS_TOOFEW(0);
  211.   
  212.   *wc=cs->tab_to_uni[*str];
  213.   return (!wc[0] && str[0]) ? MY_CS_ILSEQ : 1;
  214. }
  216. int my_wc_mb_8bit(CHARSET_INFO *cs,my_wc_t wc,
  217.   unsigned char *str,
  218.   unsigned char *end __attribute__((unused)))
  219. {
  220.   MY_UNI_IDX *idx;
  222.   if (str >= end)
  223.     return MY_CS_TOOSMALL;
  224.   
  225.   for (idx=cs->tab_from_uni; idx->tab ; idx++)
  226.   {
  227.     if (idx->from <= wc && idx->to >= wc)
  228.     {
  229.       str[0]= idx->tab[wc - idx->from];
  230.       return (!str[0] && wc) ? MY_CS_ILUNI : 1;
  231.     }
  232.   }
  233.   return MY_CS_ILUNI;
  234. }
  237. /* 
  238.    We can't use vsprintf here as it's not guaranteed to return
  239.    the length on all operating systems.
  240.    This function is also not called in a safe environment, so the
  241.    end buffer must be checked.
  242. */
  244. int my_snprintf_8bit(CHARSET_INFO *cs  __attribute__((unused)),
  245.      char* to, uint n  __attribute__((unused)),
  246.      const char* fmt, ...)
  247. {
  248.   va_list args;
  249.   int result;
  250.   va_start(args,fmt);
  251.   result= my_vsnprintf(to, n, fmt, args);
  252.   va_end(args);
  253.   return result;
  254. }
  257. void my_hash_sort_simple(CHARSET_INFO *cs,
  258.  const uchar *key, uint len,
  259.  ulong *nr1, ulong *nr2)
  260. {
  261.   register uchar *sort_order=cs->sort_order;
  262.   const uchar *pos = key;
  263.   
  264.   key+= len;
  265.   
  266.   for (; pos < (uchar*) key ; pos++)
  267.   {
  268.     nr1[0]^=(ulong) ((((uint) nr1[0] & 63)+nr2[0]) * 
  269.      ((uint) sort_order[(uint) *pos])) + (nr1[0] << 8);
  270.     nr2[0]+=3;
  271.   }
  272. }
  275. long my_strntol_8bit(CHARSET_INFO *cs,
  276.      const char *nptr, uint l, int base,
  277.      char **endptr, int *err)
  278. {
  279.   int negative;
  280.   register uint32 cutoff;
  281.   register unsigned int cutlim;
  282.   register uint32 i;
  283.   register const char *s;
  284.   register unsigned char c;
  285.   const char *save, *e;
  286.   int overflow;
  288.   *err= 0; /* Initialize error indicator */
  289. #ifdef NOT_USED
  290.   if (base < 0 || base == 1 || base > 36)
  291.     base = 10;
  292. #endif
  294.   s = nptr;
  295.   e = nptr+l;
  296.   
  297.   for ( ; s<e && my_isspace(cs, *s) ; s++);
  298.   
  299.   if (s == e)
  300.   {
  301.     goto noconv;
  302.   }
  303.   
  304.   /* Check for a sign. */
  305.   if (*s == '-')
  306.   {
  307.     negative = 1;
  308.     ++s;
  309.   }
  310.   else if (*s == '+')
  311.   {
  312.     negative = 0;
  313.     ++s;
  314.   }
  315.   else
  316.     negative = 0;
  318. #ifdef NOT_USED
  319.   if (base == 16 && s[0] == '0' && (s[1]=='X' || s[1]=='x'))
  320.     s += 2;
  321. #endif
  323. #ifdef NOT_USED
  324.   if (base == 0)
  325.   {
  326.     if (*s == '0')
  327.     {
  328.       if (s[1]=='X' || s[1]=='x')
  329.       {
  330. s += 2;
  331. base = 16;
  332.       }
  333.       else
  334. base = 8;
  335.     }
  336.     else
  337.       base = 10;
  338.   }
  339. #endif
  341.   save = s;
  342.   cutoff = ((uint32)~0L) / (uint32) base;
  343.   cutlim = (uint) (((uint32)~0L) % (uint32) base);
  345.   overflow = 0;
  346.   i = 0;
  347.   for (c = *s; s != e; c = *++s)
  348.   {
  349.     if (c>='0' && c<='9')
  350.       c -= '0';
  351.     else if (c>='A' && c<='Z')
  352.       c = c - 'A' + 10;
  353.     else if (c>='a' && c<='z')
  354.       c = c - 'a' + 10;
  355.     else
  356.       break;
  357.     if (c >= base)
  358.       break;
  359.     if (i > cutoff || (i == cutoff && c > cutlim))
  360.       overflow = 1;
  361.     else
  362.     {
  363.       i *= (uint32) base;
  364.       i += c;
  365.     }
  366.   }
  367.   
  368.   if (s == save)
  369.     goto noconv;
  370.   
  371.   if (endptr != NULL)
  372.     *endptr = (char *) s;
  373.   
  374.   if (negative)
  375.   {
  376.     if (i  > (uint32) INT_MIN32)
  377.       overflow = 1;
  378.   }
  379.   else if (i > INT_MAX32)
  380.     overflow = 1;
  381.   
  382.   if (overflow)
  383.   {
  384.     err[0]= ERANGE;
  385.     return negative ? INT_MIN32 : INT_MAX32;
  386.   }
  387.   
  388.   return (negative ? -((long) i) : (long) i);
  390. noconv:
  391.   err[0]= EDOM;
  392.   if (endptr != NULL)
  393.     *endptr = (char *) nptr;
  394.   return 0L;
  395. }
  398. ulong my_strntoul_8bit(CHARSET_INFO *cs,
  399.        const char *nptr, uint l, int base,
  400.        char **endptr, int *err)
  401. {
  402.   int negative;
  403.   register uint32 cutoff;
  404.   register unsigned int cutlim;
  405.   register uint32 i;
  406.   register const char *s;
  407.   register unsigned char c;
  408.   const char *save, *e;
  409.   int overflow;
  411.   *err= 0; /* Initialize error indicator */
  412. #ifdef NOT_USED
  413.   if (base < 0 || base == 1 || base > 36)
  414.     base = 10;
  415. #endif
  417.   s = nptr;
  418.   e = nptr+l;
  419.   
  420.   for( ; s<e && my_isspace(cs, *s); s++);
  421.   
  422.   if (s==e)
  423.   {
  424.     goto noconv;
  425.   }
  427.   if (*s == '-')
  428.   {
  429.     negative = 1;
  430.     ++s;
  431.   }
  432.   else if (*s == '+')
  433.   {
  434.     negative = 0;
  435.     ++s;
  436.   }
  437.   else
  438.     negative = 0;
  440. #ifdef NOT_USED
  441.   if (base == 16 && s[0] == '0' && (s[1]=='X' || s[1]=='x'))
  442.     s += 2;
  443. #endif
  445. #ifdef NOT_USED
  446.   if (base == 0)
  447.   {
  448.     if (*s == '0')
  449.     {
  450.       if (s[1]=='X' || s[1]=='x')
  451.       {
  452. s += 2;
  453. base = 16;
  454.       }
  455.       else
  456. base = 8;
  457.     }
  458.     else
  459.       base = 10;
  460.   }
  461. #endif
  463.   save = s;
  464.   cutoff = ((uint32)~0L) / (uint32) base;
  465.   cutlim = (uint) (((uint32)~0L) % (uint32) base);
  466.   overflow = 0;
  467.   i = 0;
  468.   
  469.   for (c = *s; s != e; c = *++s)
  470.   {
  471.     if (c>='0' && c<='9')
  472.       c -= '0';
  473.     else if (c>='A' && c<='Z')
  474.       c = c - 'A' + 10;
  475.     else if (c>='a' && c<='z')
  476.       c = c - 'a' + 10;
  477.     else
  478.       break;
  479.     if (c >= base)
  480.       break;
  481.     if (i > cutoff || (i == cutoff && c > cutlim))
  482.       overflow = 1;
  483.     else
  484.     {
  485.       i *= (uint32) base;
  486.       i += c;
  487.     }
  488.   }
  490.   if (s == save)
  491.     goto noconv;
  493.   if (endptr != NULL)
  494.     *endptr = (char *) s;
  496.   if (overflow)
  497.   {
  498.     err[0]= ERANGE;
  499.     return (~(uint32) 0);
  500.   }
  501.   
  502.   return (negative ? -((long) i) : (long) i);
  503.   
  504. noconv:
  505.   err[0]= EDOM;
  506.   if (endptr != NULL)
  507.     *endptr = (char *) nptr;
  508.   return 0L;
  509. }
  512. longlong my_strntoll_8bit(CHARSET_INFO *cs __attribute__((unused)),
  513.   const char *nptr, uint l, int base,
  514.   char **endptr,int *err)
  515. {
  516.   int negative;
  517.   register ulonglong cutoff;
  518.   register unsigned int cutlim;
  519.   register ulonglong i;
  520.   register const char *s, *e;
  521.   const char *save;
  522.   int overflow;
  524.   *err= 0; /* Initialize error indicator */
  525. #ifdef NOT_USED
  526.   if (base < 0 || base == 1 || base > 36)
  527.     base = 10;
  528. #endif
  530.   s = nptr;
  531.   e = nptr+l;
  533.   for(; s<e && my_isspace(cs,*s); s++);
  535.   if (s == e)
  536.   {
  537.     goto noconv;
  538.   }
  540.   if (*s == '-')
  541.   {
  542.     negative = 1;
  543.     ++s;
  544.   }
  545.   else if (*s == '+')
  546.   {
  547.     negative = 0;
  548.     ++s;
  549.   }
  550.   else
  551.     negative = 0;
  553. #ifdef NOT_USED
  554.   if (base == 16 && s[0] == '0' && (s[1]=='X'|| s[1]=='x'))
  555.     s += 2;
  556. #endif
  558. #ifdef NOT_USED
  559.   if (base == 0)
  560.   {
  561.     if (*s == '0')
  562.     {
  563.       if (s[1]=='X' || s[1]=='x')
  564.       {
  565. s += 2;
  566. base = 16;
  567.       }
  568.       else
  569. base = 8;
  570.     }
  571.     else
  572.       base = 10;
  573.   }
  574. #endif
  576.   save = s;
  578.   cutoff = (~(ulonglong) 0) / (unsigned long int) base;
  579.   cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
  581.   overflow = 0;
  582.   i = 0;
  583.   for ( ; s != e; s++)
  584.   {
  585.     register unsigned char c= *s;
  586.     if (c>='0' && c<='9')
  587.       c -= '0';
  588.     else if (c>='A' && c<='Z')
  589.       c = c - 'A' + 10;
  590.     else if (c>='a' && c<='z')
  591.       c = c - 'a' + 10;
  592.     else
  593.       break;
  594.     if (c >= base)
  595.       break;
  596.     if (i > cutoff || (i == cutoff && c > cutlim))
  597.       overflow = 1;
  598.     else
  599.     {
  600.       i *= (ulonglong) base;
  601.       i += c;
  602.     }
  603.   }
  605.   if (s == save)
  606.     goto noconv;
  608.   if (endptr != NULL)
  609.     *endptr = (char *) s;
  611.   if (negative)
  612.   {
  613.     if (i  > (ulonglong) LONGLONG_MIN)
  614.       overflow = 1;
  615.   }
  616.   else if (i > (ulonglong) LONGLONG_MAX)
  617.     overflow = 1;
  619.   if (overflow)
  620.   {
  621.     err[0]= ERANGE;
  622.     return negative ? LONGLONG_MIN : LONGLONG_MAX;
  623.   }
  625.   return (negative ? -((longlong) i) : (longlong) i);
  627. noconv:
  628.   err[0]= EDOM;
  629.   if (endptr != NULL)
  630.     *endptr = (char *) nptr;
  631.   return 0L;
  632. }
  635. ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
  636.    const char *nptr, uint l, int base,
  637.    char **endptr, int *err)
  638. {
  639.   int negative;
  640.   register ulonglong cutoff;
  641.   register unsigned int cutlim;
  642.   register ulonglong i;
  643.   register const char *s, *e;
  644.   const char *save;
  645.   int overflow;
  647.   *err= 0; /* Initialize error indicator */
  648. #ifdef NOT_USED
  649.   if (base < 0 || base == 1 || base > 36)
  650.     base = 10;
  651. #endif
  653.   s = nptr;
  654.   e = nptr+l;
  656.   for(; s<e && my_isspace(cs,*s); s++);
  658.   if (s == e)
  659.   {
  660.     goto noconv;
  661.   }
  663.   if (*s == '-')
  664.   {
  665.     negative = 1;
  666.     ++s;
  667.   }
  668.   else if (*s == '+')
  669.   {
  670.     negative = 0;
  671.     ++s;
  672.   }
  673.   else
  674.     negative = 0;
  676. #ifdef NOT_USED
  677.   if (base == 16 && s[0] == '0' && (s[1]=='X' || s[1]=='x'))
  678.     s += 2;
  679. #endif
  681. #ifdef NOT_USED
  682.   if (base == 0)
  683.   {
  684.     if (*s == '0')
  685.     {
  686.       if (s[1]=='X' || s[1]=='x')
  687.       {
  688. s += 2;
  689. base = 16;
  690.       }
  691.       else
  692. base = 8;
  693.     }
  694.     else
  695.       base = 10;
  696.   }
  697. #endif
  699.   save = s;
  701.   cutoff = (~(ulonglong) 0) / (unsigned long int) base;
  702.   cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
  704.   overflow = 0;
  705.   i = 0;
  706.   for ( ; s != e; s++)
  707.   {
  708.     register unsigned char c= *s;
  710.     if (c>='0' && c<='9')
  711.       c -= '0';
  712.     else if (c>='A' && c<='Z')
  713.       c = c - 'A' + 10;
  714.     else if (c>='a' && c<='z')
  715.       c = c - 'a' + 10;
  716.     else
  717.       break;
  718.     if (c >= base)
  719.       break;
  720.     if (i > cutoff || (i == cutoff && c > cutlim))
  721.       overflow = 1;
  722.     else
  723.     {
  724.       i *= (ulonglong) base;
  725.       i += c;
  726.     }
  727.   }
  729.   if (s == save)
  730.     goto noconv;
  732.   if (endptr != NULL)
  733.     *endptr = (char *) s;
  735.   if (overflow)
  736.   {
  737.     err[0]= ERANGE;
  738.     return (~(ulonglong) 0);
  739.   }
  741.   return (negative ? -((longlong) i) : (longlong) i);
  743. noconv:
  744.   err[0]= EDOM;
  745.   if (endptr != NULL)
  746.     *endptr = (char *) nptr;
  747.   return 0L;
  748. }
  750. /*
  751.   Read double from string
  753.   SYNOPSIS:
  754.     my_strntod_8bit()
  755.     cs Character set information
  756.     str String to convert to double
  757.     length Optional length for string.
  758.     end result pointer to end of converted string
  759.     err Error number if failed conversion
  760.     
  761.   NOTES:
  762.     If length is not INT_MAX32 or str[length] != 0 then the given str must
  763.     be writeable
  764.     If length == INT_MAX32 the str must be  terminated.
  766.     It's implemented this way to save a buffer allocation and a memory copy.
  768.   RETURN
  769.     Value of number in string
  770. */
  773. double my_strntod_8bit(CHARSET_INFO *cs __attribute__((unused)),
  774.        char *str, uint length,
  775.        char **end, int *err)
  776. {
  777.   if (length == INT_MAX32)
  778.     length= 65535;                          /* Should be big enough */
  779.   *end= str + length;
  780.   return my_strtod(str, end, err);
  781. }
  784. /*
  785.   This is a fast version optimized for the case of radix 10 / -10
  787.   Assume len >= 1
  788. */
  790. int my_long10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
  791.      char *dst, uint len, int radix, long int val)
  792. {
  793.   char buffer[66];
  794.   register char *p, *e;
  795.   long int new_val;
  796.   uint sign=0;
  798.   e = p = &buffer[sizeof(buffer)-1];
  799.   *p= 0;
  800.   
  801.   if (radix < 0)
  802.   {
  803.     if (val < 0)
  804.     {
  805.       val= -val;
  806.       *dst++= '-';
  807.       len--;
  808.       sign= 1;
  809.     }
  810.   }
  811.   
  812.   new_val = (long) ((unsigned long int) val / 10);
  813.   *--p    = '0'+ (char) ((unsigned long int) val - (unsigned long) new_val * 10);
  814.   val     = new_val;
  815.   
  816.   while (val != 0)
  817.   {
  818.     new_val=val/10;
  819.     *--p = '0' + (char) (val-new_val*10);
  820.     val= new_val;
  821.   }
  822.   
  823.   len= min(len, (uint) (e-p));
  824.   memcpy(dst, p, len);
  825.   return (int) len+sign;
  826. }
  829. int my_longlong10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
  830.       char *dst, uint len, int radix, longlong val)
  831. {
  832.   char buffer[65];
  833.   register char *p, *e;
  834.   long long_val;
  835.   uint sign= 0;
  836.   
  837.   if (radix < 0)
  838.   {
  839.     if (val < 0)
  840.     {
  841.       val = -val;
  842.       *dst++= '-';
  843.       len--;
  844.       sign= 1;
  845.     }
  846.   }
  847.   
  848.   e = p = &buffer[sizeof(buffer)-1];
  849.   *p= 0;
  850.   
  851.   if (val == 0)
  852.   {
  853.     *--p= '0';
  854.     len= 1;
  855.     goto cnv;
  856.   }
  857.   
  858.   while ((ulonglong) val > (ulonglong) LONG_MAX)
  859.   {
  860.     ulonglong quo=(ulonglong) val/(uint) 10;
  861.     uint rem= (uint) (val- quo* (uint) 10);
  862.     *--p = '0' + rem;
  863.     val= quo;
  864.   }
  865.   
  866.   long_val= (long) val;
  867.   while (long_val != 0)
  868.   {
  869.     long quo= long_val/10;
  870.     *--p = (char) ('0' + (long_val - quo*10));
  871.     long_val= quo;
  872.   }
  873.   
  874.   len= min(len, (uint) (e-p));
  875. cnv:
  876.   memcpy(dst, p, len);
  877.   return len+sign;
  878. }
  881. /*
  882. ** Compare string against string with wildcard
  883. ** 0 if matched
  884. ** -1 if not matched with wildcard
  885. **  1 if matched with wildcard
  886. */
  888. #ifdef LIKE_CMP_TOUPPER
  889. #define likeconv(s,A) (uchar) my_toupper(s,A)
  890. #else
  891. #define likeconv(s,A) (uchar) (s)->sort_order[(uchar) (A)]
  892. #endif
  894. #define INC_PTR(cs,A,B) (A)++
  897. int my_wildcmp_8bit(CHARSET_INFO *cs,
  898.     const char *str,const char *str_end,
  899.     const char *wildstr,const char *wildend,
  900.     int escape, int w_one, int w_many)
  901. {
  902.   int result= -1; /* Not found, using wildcards */
  904.   while (wildstr != wildend)
  905.   {
  906.     while (*wildstr != w_many && *wildstr != w_one)
  907.     {
  908.       if (*wildstr == escape && wildstr+1 != wildend)
  909. wildstr++;
  911.       if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
  912. return(1); /* No match */
  913.       if (wildstr == wildend)
  914. return(str != str_end); /* Match if both are at end */
  915.       result=1; /* Found an anchor char     */
  916.     }
  917.     if (*wildstr == w_one)
  918.     {
  919.       do
  920.       {
  921. if (str == str_end) /* Skip one char if possible */
  922.   return(result);
  923. INC_PTR(cs,str,str_end);
  924.       } while (++wildstr < wildend && *wildstr == w_one);
  925.       if (wildstr == wildend)
  926. break;
  927.     }
  928.     if (*wildstr == w_many)
  929.     { /* Found w_many */
  930.       uchar cmp;
  931.       
  932.       wildstr++;
  933.       /* Remove any '%' and '_' from the wild search string */
  934.       for (; wildstr != wildend ; wildstr++)
  935.       {
  936. if (*wildstr == w_many)
  937.   continue;
  938. if (*wildstr == w_one)
  939. {
  940.   if (str == str_end)
  941.     return(-1);
  942.   INC_PTR(cs,str,str_end);
  943.   continue;
  944. }
  945. break; /* Not a wild character */
  946.       }
  947.       if (wildstr == wildend)
  948. return(0); /* Ok if w_many is last */
  949.       if (str == str_end)
  950. return(-1);
  951.       
  952.       if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
  953. cmp= *++wildstr;
  955.       INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
  956.       cmp=likeconv(cs,cmp);
  957.       do
  958.       {
  959. while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
  960.   str++;
  961. if (str++ == str_end) return(-1);
  962. {
  963.   int tmp=my_wildcmp_8bit(cs,str,str_end,wildstr,wildend,escape,w_one,
  964.   w_many);
  965.   if (tmp <= 0)
  966.     return(tmp);
  967. }
  968.       } while (str != str_end && wildstr[0] != w_many);
  969.       return(-1);
  970.     }
  971.   }
  972.   return(str != str_end ? 1 : 0);
  973. }
  976. /*
  977. ** Calculate min_str and max_str that ranges a LIKE string.
  978. ** Arguments:
  979. ** ptr Pointer to LIKE string.
  980. ** ptr_length Length of LIKE string.
  981. ** escape Escape character in LIKE.  (Normally '').
  982. ** All escape characters should be removed from min_str and max_str
  983. ** res_length Length of min_str and max_str.
  984. ** min_str Smallest case sensitive string that ranges LIKE.
  985. ** Should be space padded to res_length.
  986. ** max_str Largest case sensitive string that ranges LIKE.
  987. ** Normally padded with the biggest character sort value.
  988. **
  989. ** The function should return 0 if ok and 1 if the LIKE string can't be
  990. ** optimized !
  991. */
  993. my_bool my_like_range_simple(CHARSET_INFO *cs,
  994.      const char *ptr,uint ptr_length,
  995.      pbool escape, pbool w_one, pbool w_many,
  996.      uint res_length,
  997.      char *min_str,char *max_str,
  998.      uint *min_length,uint *max_length)
  999. {
  1000.   const char *end= ptr + ptr_length;
  1001.   char *min_org=min_str;
  1002.   char *min_end=min_str+res_length;
  1003.   uint charlen= res_length / cs->mbmaxlen;
  1005.   for (; ptr != end && min_str != min_end && charlen > 0 ; ptr++, charlen--)
  1006.   {
  1007.     if (*ptr == escape && ptr+1 != end)
  1008.     {
  1009.       ptr++; /* Skip escape */
  1010.       *min_str++= *max_str++ = *ptr;
  1011.       continue;
  1012.     }
  1013.     if (*ptr == w_one) /* '_' in SQL */
  1014.     {
  1015.       *min_str++=''; /* This should be min char */
  1016.       *max_str++= (char) cs->max_sort_char;
  1017.       continue;
  1018.     }
  1019.     if (*ptr == w_many) /* '%' in SQL */
  1020.     {
  1021.       *min_length= (uint) (min_str - min_org);
  1022.       *max_length=res_length;
  1023.       do
  1024.       {
  1025. *min_str++= 0;
  1026. *max_str++= (char) cs->max_sort_char;
  1027.       } while (min_str != min_end);
  1028.       return 0;
  1029.     }
  1030.     *min_str++= *max_str++ = *ptr;
  1031.   }
  1032.   *min_length= *max_length = (uint) (min_str - min_org);
  1034.   while (min_str != min_end)
  1035.     *min_str++ = *max_str++ = ' '; /* Because if key compression */
  1036.   return 0;
  1037. }
  1040. ulong my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
  1041. {
  1042.   const char *str0= str;
  1043.   switch (sq)
  1044.   {
  1045.   case MY_SEQ_INTTAIL:
  1046.     if (*str == '.')
  1047.     {
  1048.       for(str++ ; str != end && *str == '0' ; str++);
  1049.       return (ulong) (str - str0);
  1050.     }
  1051.     return 0;
  1053.   case MY_SEQ_SPACES:
  1054.     for ( ; str < end ; str++)
  1055.     {
  1056.       if (!my_isspace(cs,*str))
  1057.         break;
  1058.     }
  1059.     return (ulong) (str - str0);
  1060.   default:
  1061.     return 0;
  1062.   }
  1063. }
  1066. void my_fill_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1067.    char *s, uint l, int fill)
  1068. {
  1069.   bfill(s,l,fill);
  1070. }
  1073. uint my_numchars_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1074.       const char *b, const char *e)
  1075. {
  1076.   return (uint) (e - b);
  1077. }
  1080. uint my_numcells_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1081.       const char *b, const char *e)
  1082. {
  1083.   return (uint) (e - b);
  1084. }
  1087. uint my_charpos_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1088.      const char *b  __attribute__((unused)),
  1089.      const char *e  __attribute__((unused)),
  1090.      uint pos)
  1091. {
  1092.   return pos;
  1093. }
  1096. uint my_well_formed_len_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1097.                              const char *start, const char *end,
  1098.                              uint nchars, int *error)
  1099. {
  1100.   uint nbytes= (uint) (end-start);
  1101.   *error= 0;
  1102.   return min(nbytes, nchars);
  1103. }
  1106. uint my_lengthsp_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1107.       const char *ptr, uint length)
  1108. {
  1109.   const char *end= ptr+length;
  1110.   while (end > ptr && end[-1] == ' ')
  1111.     end--;
  1112.   return (uint) (end-ptr);
  1113. }
  1116. uint my_instr_simple(CHARSET_INFO *cs,
  1117.                     const char *b, uint b_length, 
  1118.     const char *s, uint s_length,
  1119.     my_match_t *match, uint nmatch)
  1120. {
  1121.   register const uchar *str, *search, *end, *search_end;
  1122.   
  1123.   if (s_length <= b_length)
  1124.   {
  1125.     if (!s_length)
  1126.     {
  1127.       if (nmatch)
  1128.       {
  1129.         match->beg= 0;
  1130.         match->end= 0;
  1131.         match->mblen= 0;
  1132.       }
  1133.       return 1; /* Empty string is always found */
  1134.     }
  1135.     
  1136.     str= (const uchar*) b;
  1137.     search= (const uchar*) s;
  1138.     end= (const uchar*) b+b_length-s_length+1;
  1139.     search_end= (const uchar*) s + s_length;
  1140.     
  1141. skip:
  1142.     while (str != end)
  1143.     {
  1144.       if (cs->sort_order[*str++] == cs->sort_order[*search])
  1145.       {
  1146. register const uchar *i,*j;
  1148. i= str; 
  1149. j= search+1;
  1151. while (j != search_end)
  1152.   if (cs->sort_order[*i++] != cs->sort_order[*j++]) 
  1153.             goto skip;
  1154.         
  1155. if (nmatch > 0)
  1156. {
  1157.   match[0].beg= 0;
  1158.   match[0].end= str- (const uchar*)b-1;
  1159.   match[0].mblen= match[0].end;
  1160.   
  1161.   if (nmatch > 1)
  1162.   {
  1163.     match[1].beg= match[0].end;
  1164.     match[1].end= match[0].end+s_length;
  1165.     match[1].mblen= match[1].end-match[1].beg;
  1166.   }
  1167. }
  1168. return 2;
  1169.       }
  1170.     }
  1171.   }
  1172.   return 0;
  1173. }
  1176. typedef struct
  1177. {
  1178.   int nchars;
  1179.   MY_UNI_IDX uidx;
  1180. } uni_idx;
  1182. #define PLANE_SIZE 0x100
  1183. #define PLANE_NUM 0x100
  1184. #define PLANE_NUMBER(x) (((x)>>8) % PLANE_NUM)
  1186. static int pcmp(const void * f, const void * s)
  1187. {
  1188.   const uni_idx *F= (const uni_idx*) f;
  1189.   const uni_idx *S= (const uni_idx*) s;
  1190.   int res;
  1192.   if (!(res=((S->nchars)-(F->nchars))))
  1193.     res=((F->uidx.from)-(S->uidx.to));
  1194.   return res;
  1195. }
  1197. static my_bool create_fromuni(CHARSET_INFO *cs, void *(*alloc)(uint))
  1198. {
  1199.   uni_idx idx[PLANE_NUM];
  1200.   int i,n;
  1201.   
  1202.   /*
  1203.     Check that Unicode map is loaded.
  1204.     It can be not loaded when the collation is
  1205.     listed in Index.xml but not specified
  1206.     in the character set specific XML file.
  1207.   */
  1208.   if (!cs->tab_to_uni)
  1209.     return TRUE;
  1210.   
  1211.   /* Clear plane statistics */
  1212.   bzero(idx,sizeof(idx));
  1213.   
  1214.   /* Count number of characters in each plane */
  1215.   for (i=0; i< 0x100; i++)
  1216.   {
  1217.     uint16 wc=cs->tab_to_uni[i];
  1218.     int pl= PLANE_NUMBER(wc);
  1219.     
  1220.     if (wc || !i)
  1221.     {
  1222.       if (!idx[pl].nchars)
  1223.       {
  1224.         idx[pl].uidx.from=wc;
  1225.         idx[pl].uidx.to=wc;
  1226.       }else
  1227.       {
  1228.         idx[pl].uidx.from=wc<idx[pl].uidx.from?wc:idx[pl].uidx.from;
  1229.         idx[pl].uidx.to=wc>idx[pl].uidx.to?wc:idx[pl].uidx.to;
  1230.       }
  1231.       idx[pl].nchars++;
  1232.     }
  1233.   }
  1234.   
  1235.   /* Sort planes in descending order */
  1236.   qsort(&idx,PLANE_NUM,sizeof(uni_idx),&pcmp);
  1237.   
  1238.   for (i=0; i < PLANE_NUM; i++)
  1239.   {
  1240.     int ch,numchars;
  1241.     
  1242.     /* Skip empty plane */
  1243.     if (!idx[i].nchars)
  1244.       break;
  1245.     
  1246.     numchars=idx[i].uidx.to-idx[i].uidx.from+1;
  1247.     if (!(idx[i].uidx.tab=(uchar*) alloc(numchars * sizeof(*idx[i].uidx.tab))))
  1248.       return TRUE;
  1249.     
  1250.     bzero(idx[i].uidx.tab,numchars*sizeof(*idx[i].uidx.tab));
  1251.     
  1252.     for (ch=1; ch < PLANE_SIZE; ch++)
  1253.     {
  1254.       uint16 wc=cs->tab_to_uni[ch];
  1255.       if (wc >= idx[i].uidx.from && wc <= idx[i].uidx.to && wc)
  1256.       {
  1257.         int ofs= wc - idx[i].uidx.from;
  1258.         idx[i].uidx.tab[ofs]= ch;
  1259.       }
  1260.     }
  1261.   }
  1262.   
  1263.   /* Allocate and fill reverse table for each plane */
  1264.   n=i;
  1265.   if (!(cs->tab_from_uni= (MY_UNI_IDX*) alloc(sizeof(MY_UNI_IDX)*(n+1))))
  1266.     return TRUE;
  1268.   for (i=0; i< n; i++)
  1269.     cs->tab_from_uni[i]= idx[i].uidx;
  1270.   
  1271.   /* Set end-of-list marker */
  1272.   bzero(&cs->tab_from_uni[i],sizeof(MY_UNI_IDX));
  1273.   return FALSE;
  1274. }
  1276. static my_bool my_cset_init_8bit(CHARSET_INFO *cs, void *(*alloc)(uint))
  1277. {
  1278.   return create_fromuni(cs, alloc);
  1279. }
  1281. static void set_max_sort_char(CHARSET_INFO *cs)
  1282. {
  1283.   uchar max_char;
  1284.   uint  i;
  1285.   
  1286.   if (!cs->sort_order)
  1287.     return;
  1288.   
  1289.   max_char=cs->sort_order[(uchar) cs->max_sort_char];
  1290.   for (i= 0; i < 256; i++)
  1291.   {
  1292.     if ((uchar) cs->sort_order[i] > max_char)
  1293.     {
  1294.       max_char=(uchar) cs->sort_order[i];
  1295.       cs->max_sort_char= i;
  1296.     }
  1297.   }
  1298. }
  1300. static my_bool my_coll_init_simple(CHARSET_INFO *cs,
  1301.                                    void *(*alloc)(uint) __attribute__((unused)))
  1302. {
  1303.   set_max_sort_char(cs);
  1304.   return FALSE;
  1305. }
  1308. longlong my_strtoll10_8bit(CHARSET_INFO *cs __attribute__((unused)),
  1309.                            const char *nptr, char **endptr, int *error)
  1310. {
  1311.   return my_strtoll10(nptr, endptr, error);
  1312. }
  1315. MY_CHARSET_HANDLER my_charset_8bit_handler=
  1316. {
  1317.     my_cset_init_8bit,
  1318.     NULL, /* ismbchar      */
  1319.     my_mbcharlen_8bit, /* mbcharlen     */
  1320.     my_numchars_8bit,
  1321.     my_charpos_8bit,
  1322.     my_well_formed_len_8bit,
  1323.     my_lengthsp_8bit,
  1324.     my_numcells_8bit,
  1325.     my_mb_wc_8bit,
  1326.     my_wc_mb_8bit,
  1327.     my_caseup_str_8bit,
  1328.     my_casedn_str_8bit,
  1329.     my_caseup_8bit,
  1330.     my_casedn_8bit,
  1331.     my_snprintf_8bit,
  1332.     my_long10_to_str_8bit,
  1333.     my_longlong10_to_str_8bit,
  1334.     my_fill_8bit,
  1335.     my_strntol_8bit,
  1336.     my_strntoul_8bit,
  1337.     my_strntoll_8bit,
  1338.     my_strntoull_8bit,
  1339.     my_strntod_8bit,
  1340.     my_strtoll10_8bit,
  1341.     my_scan_8bit
  1342. };
  1344. MY_COLLATION_HANDLER my_collation_8bit_simple_ci_handler =
  1345. {
  1346.     my_coll_init_simple, /* init */
  1347.     my_strnncoll_simple,
  1348.     my_strnncollsp_simple,
  1349.     my_strnxfrm_simple,
  1350.     my_like_range_simple,
  1351.     my_wildcmp_8bit,
  1352.     my_strcasecmp_8bit,
  1353.     my_instr_simple,
  1354.     my_hash_sort_simple
  1355. };