ctype-bin.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:13k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2002 MySQL AB & tommy@valley.ne.jp.
  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 */
  17. /* This file is for binary pseudo charset, created by bar@mysql.com */
  18. #include <my_global.h>
  19. #include "m_string.h"
  20. #include "m_ctype.h"
  21. static uchar ctype_bin[]=
  22. {
  23.   0,
  24.   32, 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 32, 32,
  25.   32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  26.   72, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
  27.   132,132,132,132,132,132,132,132,132,132, 16, 16, 16, 16, 16, 16,
  28.   16,129,129,129,129,129,129,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  29.   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 16, 16, 16, 16, 16,
  30.   16,130,130,130,130,130,130,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  31.   2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 16, 16, 16, 16, 32,
  32.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  33.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  34.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  35.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  36.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  37.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  38.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  39.   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  40. };
  41. /* Dummy array for toupper / tolower / sortorder */
  42. static uchar bin_char_array[] =
  43. {
  44.     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  45.    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  46.    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  47.    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  48.    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  49.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  50.    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
  51.   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
  52.   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  53.   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  54.   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  55.   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  56.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  57.   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  58.   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
  59.   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
  60. };
  61. static my_bool 
  62. my_coll_init_8bit_bin(CHARSET_INFO *cs,
  63.                       void *(*alloc)(uint) __attribute__((unused)))
  64. {
  65.   cs->max_sort_char=255; 
  66.   return FALSE;
  67. }
  68. static int my_strnncoll_binary(CHARSET_INFO * cs __attribute__((unused)),
  69.                                const uchar *s, uint slen,
  70.                                const uchar *t, uint tlen,
  71.                                my_bool t_is_prefix)
  72. {
  73.   uint len=min(slen,tlen);
  74.   int cmp= memcmp(s,t,len);
  75.   return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
  76. }
  77. /*
  78.   Compare two strings. Result is sign(first_argument - second_argument)
  79.   SYNOPSIS
  80.     my_strnncollsp_binary()
  81.     cs Chararacter set
  82.     s String to compare
  83.     slen Length of 's'
  84.     t String to compare
  85.     tlen Length of 't'
  86.   NOTE
  87.    This function is used for real binary strings, i.e. for
  88.    BLOB, BINARY(N) and VARBINARY(N).
  89.    It compares trailing spaces as spaces.
  90.   RETURN
  91.   < 0 s < t
  92.   0 s == t
  93.   > 0 s > t
  94. */
  95. static int my_strnncollsp_binary(CHARSET_INFO * cs __attribute__((unused)),
  96.                                  const uchar *s, uint slen,
  97.                                  const uchar *t, uint tlen)
  98. {
  99.   return my_strnncoll_binary(cs,s,slen,t,tlen,0);
  100. }
  101. static int my_strnncoll_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
  102.                                  const uchar *s, uint slen,
  103.                                  const uchar *t, uint tlen,
  104.                                  my_bool t_is_prefix)
  105. {
  106.   uint len=min(slen,tlen);
  107.   int cmp= memcmp(s,t,len);
  108.   return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
  109. }
  110. /*
  111.   Compare two strings. Result is sign(first_argument - second_argument)
  112.   SYNOPSIS
  113.     my_strnncollsp_8bit_bin()
  114.     cs Chararacter set
  115.     s String to compare
  116.     slen Length of 's'
  117.     t String to compare
  118.     tlen Length of 't'
  119.   NOTE
  120.    This function is used for character strings with binary collations.
  121.    The shorter string is extended with end space to be as long as the longer
  122.    one.
  123.   RETURN
  124.   < 0 s < t
  125.   0 s == t
  126.   > 0 s > t
  127. */
  128. static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
  129.                                    const uchar *a, uint a_length, 
  130.                                    const uchar *b, uint b_length)
  131. {
  132.   const uchar *end;
  133.   uint length;
  134.   end= a + (length= min(a_length, b_length));
  135.   while (a < end)
  136.   {
  137.     if (*a++ != *b++)
  138.       return ((int) a[-1] - (int) b[-1]);
  139.   }
  140.   if (a_length != b_length)
  141.   {
  142.     int swap= 1;
  143.     /*
  144.       Check the next not space character of the longer key. If it's < ' ',
  145.       then it's smaller than the other key.
  146.     */
  147.     if (a_length < b_length)
  148.     {
  149.       /* put shorter key in s */
  150.       a_length= b_length;
  151.       a= b;
  152.       swap= -1; /* swap sign of result */
  153.     }
  154.     for (end= a + a_length-length; a < end ; a++)
  155.     {
  156.       if (*a != ' ')
  157. return (*a < ' ') ? -swap : swap;
  158.     }
  159.   }
  160.   return 0;
  161. }
  162. /* This function is used for all conversion functions */
  163. static void my_case_str_bin(CHARSET_INFO *cs __attribute__((unused)),
  164.     char *str __attribute__((unused)))
  165. {
  166. }
  167. static void my_case_bin(CHARSET_INFO *cs __attribute__((unused)),
  168. char *str __attribute__((unused)),
  169. uint length __attribute__((unused)))
  170. {
  171. }
  172. static int my_strcasecmp_bin(CHARSET_INFO * cs __attribute__((unused)),
  173.      const char *s, const char *t)
  174. {
  175.   return strcmp(s,t);
  176. }
  177. int my_mbcharlen_8bit(CHARSET_INFO *cs __attribute__((unused)),
  178.       uint c __attribute__((unused)))
  179. {
  180.   return 1;
  181. }
  182. static int my_mb_wc_bin(CHARSET_INFO *cs __attribute__((unused)),
  183. my_wc_t *wc,
  184. const unsigned char *str,
  185. const unsigned char *end __attribute__((unused)))
  186. {
  187.   if (str >= end)
  188.     return MY_CS_TOOFEW(0);
  189.   
  190.   *wc=str[0];
  191.   return 1;
  192. }
  193. static int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
  194. my_wc_t wc,
  195. unsigned char *s,
  196. unsigned char *e __attribute__((unused)))
  197. {
  198.   if (s >= e)
  199.     return MY_CS_TOOSMALL;
  200.   if (wc < 256)
  201.   {
  202.     s[0]= (char) wc;
  203.     return 1;
  204.   }
  205.   return MY_CS_ILUNI;
  206. }
  207. void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
  208.       const uchar *key, uint len,ulong *nr1, ulong *nr2)
  209. {
  210.   const uchar *pos = key;
  211.   
  212.   key+= len;
  213.   
  214.   for (; pos < (uchar*) key ; pos++)
  215.   {
  216.     nr1[0]^=(ulong) ((((uint) nr1[0] & 63)+nr2[0]) * 
  217.      ((uint)*pos)) + (nr1[0] << 8);
  218.     nr2[0]+=3;
  219.   }
  220. }
  221. /*
  222.   The following defines is here to keep the following code identical to
  223.   the one in ctype-simple.c
  224. */
  225. #define likeconv(s,A) (A)
  226. #define INC_PTR(cs,A,B) (A)++
  227. static int my_wildcmp_bin(CHARSET_INFO *cs,
  228.    const char *str,const char *str_end,
  229.    const char *wildstr,const char *wildend,
  230.    int escape, int w_one, int w_many)
  231. {
  232.   int result= -1; /* Not found, using wildcards */
  233.   
  234.   while (wildstr != wildend)
  235.   {
  236.     while (*wildstr != w_many && *wildstr != w_one)
  237.     {
  238.       if (*wildstr == escape && wildstr+1 != wildend)
  239. wildstr++;
  240.       if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
  241. return(1); /* No match */
  242.       if (wildstr == wildend)
  243. return(str != str_end); /* Match if both are at end */
  244.       result=1; /* Found an anchor char */
  245.     }
  246.     if (*wildstr == w_one)
  247.     {
  248.       do
  249.       {
  250. if (str == str_end) /* Skip one char if possible */
  251.   return(result);
  252. INC_PTR(cs,str,str_end);
  253.       } while (++wildstr < wildend && *wildstr == w_one);
  254.       if (wildstr == wildend)
  255. break;
  256.     }
  257.     if (*wildstr == w_many)
  258.     { /* Found w_many */
  259.       uchar cmp;
  260.       wildstr++;
  261.       /* Remove any '%' and '_' from the wild search string */
  262.       for (; wildstr != wildend ; wildstr++)
  263.       {
  264. if (*wildstr == w_many)
  265.   continue;
  266. if (*wildstr == w_one)
  267. {
  268.   if (str == str_end)
  269.     return(-1);
  270.   INC_PTR(cs,str,str_end);
  271.   continue;
  272. }
  273. break; /* Not a wild character */
  274.       }
  275.       if (wildstr == wildend)
  276. return(0); /* match if w_many is last */
  277.       if (str == str_end)
  278. return(-1);
  279.       
  280.       if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
  281. cmp= *++wildstr;
  282.       INC_PTR(cs,wildstr,wildend); /* This is compared through cmp */
  283.       cmp=likeconv(cs,cmp);
  284.       do
  285.       {
  286. while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
  287.   str++;
  288. if (str++ == str_end)
  289.   return(-1);
  290. {
  291.   int tmp=my_wildcmp_bin(cs,str,str_end,wildstr,wildend,escape,w_one,
  292.  w_many);
  293.   if (tmp <= 0)
  294.     return(tmp);
  295. }
  296.       } while (str != str_end && wildstr[0] != w_many);
  297.       return(-1);
  298.     }
  299.   }
  300.   return(str != str_end ? 1 : 0);
  301. }
  302. static int my_strnxfrm_bin(CHARSET_INFO *cs __attribute__((unused)),
  303.                            uchar * dest, uint dstlen,
  304.                            const uchar *src, uint srclen)
  305. {
  306.   if (dest != src)
  307.     memcpy(dest, src, min(dstlen,srclen));
  308.   if (dstlen > srclen)
  309.     bfill(dest + srclen, dstlen - srclen, 0);
  310.   return dstlen;
  311. }
  312. static
  313. int my_strnxfrm_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
  314.                          uchar * dest, uint dstlen,
  315.                          const uchar *src, uint srclen)
  316. {
  317.   if (dest != src)
  318.     memcpy(dest, src, min(dstlen,srclen));
  319.   if (dstlen > srclen)
  320.     bfill(dest + srclen, dstlen - srclen, ' ');
  321.   return dstlen;
  322. }
  323. static
  324. uint my_instr_bin(CHARSET_INFO *cs __attribute__((unused)),
  325.   const char *b, uint b_length,
  326.   const char *s, uint s_length,
  327.   my_match_t *match, uint nmatch)
  328. {
  329.   register const uchar *str, *search, *end, *search_end;
  330.   if (s_length <= b_length)
  331.   {
  332.     if (!s_length)
  333.     {
  334.       if (nmatch)
  335.       {
  336.         match->beg= 0;
  337.         match->end= 0;
  338.         match->mblen= 0;
  339.       }
  340.       return 1; /* Empty string is always found */
  341.     }
  342.     str= (const uchar*) b;
  343.     search= (const uchar*) s;
  344.     end= (const uchar*) b+b_length-s_length+1;
  345.     search_end= (const uchar*) s + s_length;
  346. skip:
  347.     while (str != end)
  348.     {
  349.       if ( (*str++) == (*search))
  350.       {
  351. register const uchar *i,*j;
  352. i= str;
  353. j= search+1;
  354. while (j != search_end)
  355.   if ((*i++) != (*j++))
  356.             goto skip;
  357.         if (nmatch > 0)
  358. {
  359.   match[0].beg= 0;
  360.   match[0].end= str- (const uchar*)b-1;
  361.   match[0].mblen= match[0].end;
  362.   if (nmatch > 1)
  363.   {
  364.     match[1].beg= match[0].end;
  365.     match[1].end= match[0].end+s_length;
  366.     match[1].mblen= match[1].end-match[1].beg;
  367.   }
  368. }
  369. return 2;
  370.       }
  371.     }
  372.   }
  373.   return 0;
  374. }
  375. MY_COLLATION_HANDLER my_collation_8bit_bin_handler =
  376. {
  377.     my_coll_init_8bit_bin,
  378.     my_strnncoll_8bit_bin,
  379.     my_strnncollsp_8bit_bin,
  380.     my_strnxfrm_8bit_bin,
  381.     my_like_range_simple,
  382.     my_wildcmp_bin,
  383.     my_strcasecmp_bin,
  384.     my_instr_bin,
  385.     my_hash_sort_bin
  386. };
  387. static MY_COLLATION_HANDLER my_collation_binary_handler =
  388. {
  389.     NULL, /* init */
  390.     my_strnncoll_binary,
  391.     my_strnncollsp_binary,
  392.     my_strnxfrm_bin,
  393.     my_like_range_simple,
  394.     my_wildcmp_bin,
  395.     my_strcasecmp_bin,
  396.     my_instr_bin,
  397.     my_hash_sort_bin
  398. };
  399. static MY_CHARSET_HANDLER my_charset_handler=
  400. {
  401.     NULL, /* init */
  402.     NULL, /* ismbchar      */
  403.     my_mbcharlen_8bit, /* mbcharlen     */
  404.     my_numchars_8bit,
  405.     my_charpos_8bit,
  406.     my_well_formed_len_8bit,
  407.     my_lengthsp_8bit,
  408.     my_numcells_8bit,
  409.     my_mb_wc_bin,
  410.     my_wc_mb_bin,
  411.     my_case_str_bin,
  412.     my_case_str_bin,
  413.     my_case_bin,
  414.     my_case_bin,
  415.     my_snprintf_8bit,
  416.     my_long10_to_str_8bit,
  417.     my_longlong10_to_str_8bit,
  418.     my_fill_8bit,
  419.     my_strntol_8bit,
  420.     my_strntoul_8bit,
  421.     my_strntoll_8bit,
  422.     my_strntoull_8bit,
  423.     my_strntod_8bit,
  424.     my_strtoll10_8bit,
  425.     my_scan_8bit
  426. };
  427. CHARSET_INFO my_charset_bin =
  428. {
  429.     63,0,0, /* number        */
  430.     MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_PRIMARY,/* state        */
  431.     "binary", /* cs name    */
  432.     "binary", /* name          */
  433.     "", /* comment       */
  434.     NULL, /* tailoring     */
  435.     ctype_bin, /* ctype         */
  436.     bin_char_array, /* to_lower      */
  437.     bin_char_array, /* to_upper      */
  438.     NULL, /* sort_order    */
  439.     NULL, /* contractions */
  440.     NULL, /* sort_order_big*/
  441.     NULL, /* tab_to_uni    */
  442.     NULL, /* tab_from_uni  */
  443.     NULL, /* state_map    */
  444.     NULL, /* ident_map    */
  445.     1, /* strxfrm_multiply */
  446.     1, /* mbminlen      */
  447.     1, /* mbmaxlen      */
  448.     0, /* min_sort_char */
  449.     255, /* max_sort_char */
  450.     0,                          /* escape_with_backslash_is_dangerous */
  451.     &my_charset_handler,
  452.     &my_collation_binary_handler
  453. };