~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 MySQL AB

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

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

   the Free Software Foundation; version 2 of the License.

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

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

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

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

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/*

 * This file is basicly usa7 character sets with some extra functions

 * for big5 handling

*/

/*

 * This comment is parsed by configure to create ctype.c,

 * so don't change it unless you know what you are doing.

 *

 * .configure. strxfrm_multiply_big5=1

 * .configure. mbmaxlen_big5=2

 */

#include <my_global.h>

#include "m_string.h"

#include "m_ctype.h"

#ifdef HAVE_CHARSET_big5

/* 

  Support for Chinese(BIG5) characters, by jou@nematic.ieo.nctu.edu.tw

  modified by Wei He (hewei@mail.ied.ac.cn) 

  modified by Alex Barkov <bar@udm.net>

*/

#define isbig5head(c) (0xa1<=(uchar)(c) && (uchar)(c)<=0xf9)

#define isbig5tail(c) ((0x40<=(uchar)(c) && (uchar)(c)<=0x7e) || \

                      (0xa1<=(uchar)(c) && (uchar)(c)<=0xfe))

#define isbig5code(c,d) (isbig5head(c) && isbig5tail(d))

#define big5code(c,d)   (((uchar)(c) <<8) | (uchar)(d))

#define big5head(e)	((uchar)(e>>8))

#define big5tail(e)	((uchar)(e&0xff))

static uchar ctype_big5[257] =

{

  0,				/* For standard library */

  32,32,32,32,32,32,32,32,32,40,40,40,40,40,32,32,

  32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,

  72,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,

  132,132,132,132,132,132,132,132,132,132,16,16,16,16,16,16,

  16,129,129,129,129,129,129,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,16,16,16,16,16,

  16,130,130,130,130,130,130,2,2,2,2,2,2,2,2,2,

  2,2,2,2,2,2,2,2,2,2,2,16,16,16,16,32,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

  3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,

};

static uchar to_lower_big5[]=

{

  '\000','\001','\002','\003','\004','\005','\006','\007',

  '\010','\011','\012','\013','\014','\015','\016','\017',

  '\020','\021','\022','\023','\024','\025','\026','\027',

  '\030','\031','\032','\033','\034','\035','\036','\037',

  ' ',	 '!',	'"',   '#',   '$',   '%',   '&',   '\'',

  '(',	 ')',	'*',   '+',   ',',   '-',   '.',   '/',

  '0',	 '1',	'2',   '3',   '4',   '5',   '6',   '7',

  '8',	 '9',	':',   ';',   '<',   '=',   '>',   '?',

  '@',	 'a',	'b',   'c',   'd',   'e',   'f',   'g',

  'h',	 'i',	'j',   'k',   'l',   'm',   'n',   'o',

  'p',	 'q',	'r',   's',   't',   'u',   'v',   'w',

  'x',	 'y',	'z',   '[',   '\\',  ']',   '^',   '_',

  '`',	 'a',	'b',   'c',   'd',   'e',   'f',   'g',

  'h',	 'i',	'j',   'k',   'l',   'm',   'n',   'o',

  'p',	 'q',	'r',   's',   't',   'u',   'v',   'w',

  'x',	 'y',	'z',   '{',   '|',   '}',   '~',   '\177',

  (uchar) '\200',(uchar) '\201',(uchar) '\202',(uchar) '\203',(uchar) '\204',(uchar) '\205',(uchar) '\206',(uchar) '\207',

  (uchar) '\210',(uchar) '\211',(uchar) '\212',(uchar) '\213',(uchar) '\214',(uchar) '\215',(uchar) '\216',(uchar) '\217',

  (uchar) '\220',(uchar) '\221',(uchar) '\222',(uchar) '\223',(uchar) '\224',(uchar) '\225',(uchar) '\226',(uchar) '\227',

  (uchar) '\230',(uchar) '\231',(uchar) '\232',(uchar) '\233',(uchar) '\234',(uchar) '\235',(uchar) '\236',(uchar) '\237',

  (uchar) '\240',(uchar) '\241',(uchar) '\242',(uchar) '\243',(uchar) '\244',(uchar) '\245',(uchar) '\246',(uchar) '\247',

  (uchar) '\250',(uchar) '\251',(uchar) '\252',(uchar) '\253',(uchar) '\254',(uchar) '\255',(uchar) '\256',(uchar) '\257',

  (uchar) '\260',(uchar) '\261',(uchar) '\262',(uchar) '\263',(uchar) '\264',(uchar) '\265',(uchar) '\266',(uchar) '\267',

  (uchar) '\270',(uchar) '\271',(uchar) '\272',(uchar) '\273',(uchar) '\274',(uchar) '\275',(uchar) '\276',(uchar) '\277',

  (uchar) '\300',(uchar) '\301',(uchar) '\302',(uchar) '\303',(uchar) '\304',(uchar) '\305',(uchar) '\306',(uchar) '\307',

  (uchar) '\310',(uchar) '\311',(uchar) '\312',(uchar) '\313',(uchar) '\314',(uchar) '\315',(uchar) '\316',(uchar) '\317',

  (uchar) '\320',(uchar) '\321',(uchar) '\322',(uchar) '\323',(uchar) '\324',(uchar) '\325',(uchar) '\326',(uchar) '\327',

  (uchar) '\330',(uchar) '\331',(uchar) '\332',(uchar) '\333',(uchar) '\334',(uchar) '\335',(uchar) '\336',(uchar) '\337',

  (uchar) '\340',(uchar) '\341',(uchar) '\342',(uchar) '\343',(uchar) '\344',(uchar) '\345',(uchar) '\346',(uchar) '\347',

  (uchar) '\350',(uchar) '\351',(uchar) '\352',(uchar) '\353',(uchar) '\354',(uchar) '\355',(uchar) '\356',(uchar) '\357',

  (uchar) '\360',(uchar) '\361',(uchar) '\362',(uchar) '\363',(uchar) '\364',(uchar) '\365',(uchar) '\366',(uchar) '\367',

  (uchar) '\370',(uchar) '\371',(uchar) '\372',(uchar) '\373',(uchar) '\374',(uchar) '\375',(uchar) '\376',(uchar) '\377',

};

static uchar to_upper_big5[]=

{

  '\000','\001','\002','\003','\004','\005','\006','\007',

  '\010','\011','\012','\013','\014','\015','\016','\017',

  '\020','\021','\022','\023','\024','\025','\026','\027',

  '\030','\031','\032','\033','\034','\035','\036','\037',

  ' ',	 '!',	'"',   '#',   '$',   '%',   '&',   '\'',

  '(',	 ')',	'*',   '+',   ',',   '-',   '.',   '/',

  '0',	 '1',	'2',   '3',   '4',   '5',   '6',   '7',

  '8',	 '9',	':',   ';',   '<',   '=',   '>',   '?',

  '@',	 'A',	'B',   'C',   'D',   'E',   'F',   'G',

  'H',	 'I',	'J',   'K',   'L',   'M',   'N',   'O',

  'P',	 'Q',	'R',   'S',   'T',   'U',   'V',   'W',

  'X',	 'Y',	'Z',   '[',   '\\',  ']',   '^',   '_',

  '`',	 'A',	'B',   'C',   'D',   'E',   'F',   'G',

  'H',	 'I',	'J',   'K',   'L',   'M',   'N',   'O',

  'P',	 'Q',	'R',   'S',   'T',   'U',   'V',   'W',

  'X',	 'Y',	'Z',   '{',   '|',   '}',   '~',   '\177',

  (uchar) '\200',(uchar) '\201',(uchar) '\202',(uchar) '\203',(uchar) '\204',(uchar) '\205',(uchar) '\206',(uchar) '\207',

  (uchar) '\210',(uchar) '\211',(uchar) '\212',(uchar) '\213',(uchar) '\214',(uchar) '\215',(uchar) '\216',(uchar) '\217',

  (uchar) '\220',(uchar) '\221',(uchar) '\222',(uchar) '\223',(uchar) '\224',(uchar) '\225',(uchar) '\226',(uchar) '\227',

  (uchar) '\230',(uchar) '\231',(uchar) '\232',(uchar) '\233',(uchar) '\234',(uchar) '\235',(uchar) '\236',(uchar) '\237',

  (uchar) '\240',(uchar) '\241',(uchar) '\242',(uchar) '\243',(uchar) '\244',(uchar) '\245',(uchar) '\246',(uchar) '\247',

  (uchar) '\250',(uchar) '\251',(uchar) '\252',(uchar) '\253',(uchar) '\254',(uchar) '\255',(uchar) '\256',(uchar) '\257',

  (uchar) '\260',(uchar) '\261',(uchar) '\262',(uchar) '\263',(uchar) '\264',(uchar) '\265',(uchar) '\266',(uchar) '\267',

  (uchar) '\270',(uchar) '\271',(uchar) '\272',(uchar) '\273',(uchar) '\274',(uchar) '\275',(uchar) '\276',(uchar) '\277',

  (uchar) '\300',(uchar) '\301',(uchar) '\302',(uchar) '\303',(uchar) '\304',(uchar) '\305',(uchar) '\306',(uchar) '\307',

  (uchar) '\310',(uchar) '\311',(uchar) '\312',(uchar) '\313',(uchar) '\314',(uchar) '\315',(uchar) '\316',(uchar) '\317',

  (uchar) '\320',(uchar) '\321',(uchar) '\322',(uchar) '\323',(uchar) '\324',(uchar) '\325',(uchar) '\326',(uchar) '\327',

  (uchar) '\330',(uchar) '\331',(uchar) '\332',(uchar) '\333',(uchar) '\334',(uchar) '\335',(uchar) '\336',(uchar) '\337',

  (uchar) '\340',(uchar) '\341',(uchar) '\342',(uchar) '\343',(uchar) '\344',(uchar) '\345',(uchar) '\346',(uchar) '\347',

  (uchar) '\350',(uchar) '\351',(uchar) '\352',(uchar) '\353',(uchar) '\354',(uchar) '\355',(uchar) '\356',(uchar) '\357',

  (uchar) '\360',(uchar) '\361',(uchar) '\362',(uchar) '\363',(uchar) '\364',(uchar) '\365',(uchar) '\366',(uchar) '\367',

  (uchar) '\370',(uchar) '\371',(uchar) '\372',(uchar) '\373',(uchar) '\374',(uchar) '\375',(uchar) '\376',(uchar) '\377',

};

static uchar sort_order_big5[]=

{

  '\000','\001','\002','\003','\004','\005','\006','\007',

  '\010','\011','\012','\013','\014','\015','\016','\017',

  '\020','\021','\022','\023','\024','\025','\026','\027',

  '\030','\031','\032','\033','\034','\035','\036','\037',

  ' ',	 '!',	'"',   '#',   '$',   '%',   '&',   '\'',

  '(',	 ')',	'*',   '+',   ',',   '-',   '.',   '/',

  '0',	 '1',	'2',   '3',   '4',   '5',   '6',   '7',

  '8',	 '9',	':',   ';',   '<',   '=',   '>',   '?',

  '@',	 'A',	'B',   'C',   'D',   'E',   'F',   'G',

  'H',	 'I',	'J',   'K',   'L',   'M',   'N',   'O',

  'P',	 'Q',	'R',   'S',   'T',   'U',   'V',   'W',

  'X',	 'Y',	'Z',   '\\',  ']',   '[',   '^',   '_',

  'E',	 'A',	'B',   'C',   'D',   'E',   'F',   'G',

  'H',	 'I',	'J',   'K',   'L',   'M',   'N',   'O',

  'P',	 'Q',	'R',   'S',   'T',   'U',   'V',   'W',

  'X',	 'Y',	'Z',   '{',   '|',   '}',   'Y',   '\177',

  (uchar) '\200',(uchar) '\201',(uchar) '\202',(uchar) '\203',(uchar) '\204',(uchar) '\205',(uchar) '\206',(uchar) '\207',

  (uchar) '\210',(uchar) '\211',(uchar) '\212',(uchar) '\213',(uchar) '\214',(uchar) '\215',(uchar) '\216',(uchar) '\217',

  (uchar) '\220',(uchar) '\221',(uchar) '\222',(uchar) '\223',(uchar) '\224',(uchar) '\225',(uchar) '\226',(uchar) '\227',

  (uchar) '\230',(uchar) '\231',(uchar) '\232',(uchar) '\233',(uchar) '\234',(uchar) '\235',(uchar) '\236',(uchar) '\237',

  (uchar) '\240',(uchar) '\241',(uchar) '\242',(uchar) '\243',(uchar) '\244',(uchar) '\245',(uchar) '\246',(uchar) '\247',

  (uchar) '\250',(uchar) '\251',(uchar) '\252',(uchar) '\253',(uchar) '\254',(uchar) '\255',(uchar) '\256',(uchar) '\257',

  (uchar) '\260',(uchar) '\261',(uchar) '\262',(uchar) '\263',(uchar) '\264',(uchar) '\265',(uchar) '\266',(uchar) '\267',

  (uchar) '\270',(uchar) '\271',(uchar) '\272',(uchar) '\273',(uchar) '\274',(uchar) '\275',(uchar) '\276',(uchar) '\277',

  (uchar) '\300',(uchar) '\301',(uchar) '\302',(uchar) '\303',(uchar) '\304',(uchar) '\305',(uchar) '\306',(uchar) '\307',

  (uchar) '\310',(uchar) '\311',(uchar) '\312',(uchar) '\313',(uchar) '\314',(uchar) '\315',(uchar) '\316',(uchar) '\317',

  (uchar) '\320',(uchar) '\321',(uchar) '\322',(uchar) '\323',(uchar) '\324',(uchar) '\325',(uchar) '\326',(uchar) '\327',

  (uchar) '\330',(uchar) '\331',(uchar) '\332',(uchar) '\333',(uchar) '\334',(uchar) '\335',(uchar) '\336',(uchar) '\337',

  (uchar) '\340',(uchar) '\341',(uchar) '\342',(uchar) '\343',(uchar) '\344',(uchar) '\345',(uchar) '\346',(uchar) '\347',

  (uchar) '\350',(uchar) '\351',(uchar) '\352',(uchar) '\353',(uchar) '\354',(uchar) '\355',(uchar) '\356',(uchar) '\357',

  (uchar) '\360',(uchar) '\361',(uchar) '\362',(uchar) '\363',(uchar) '\364',(uchar) '\365',(uchar) '\366',(uchar) '\367',

  (uchar) '\370',(uchar) '\371',(uchar) '\372',(uchar) '\373',(uchar) '\374',(uchar) '\375',(uchar) '\376',(uchar) '\377',

};

static uint16 big5strokexfrm(uint16 i)

{

  if ((i == 0xA440) || (i == 0xA441))  return 0xA440;

  else if (((i >= 0xA442) && (i <= 0xA453)) || ((i >= 0xC940) && (i <= 0xC944)))  return 0xA442;

  else if (((i >= 0xA454) && (i <= 0xA47E)) || ((i >= 0xC945) && (i <= 0xC94C)))  return 0xA454;

  else if (((i >= 0xA4A1) && (i <= 0xA4FD)) || ((i >= 0xC94D) && (i <= 0xC962)))  return 0xA4A1;

  else if (((i >= 0xA4FE) && (i <= 0xA5DF)) || ((i >= 0xC963) && (i <= 0xC9AA)))  return 0xA4FE;

  else if (((i >= 0xA5E0) && (i <= 0xA6E9)) || ((i >= 0xC9AB) && (i <= 0xCA59)))  return 0xA5E0;

  else if (((i >= 0xA6EA) && (i <= 0xA8C2)) || ((i >= 0xCA5A) && (i <= 0xCBB0)))  return 0xA6EA;

  else if ((i == 0xA260) || ((i >= 0xA8C3) && (i <= 0xAB44)) || ((i >= 0xCBB1) && (i <= 0xCDDC)))  return 0xA8C3;

  else if ((i == 0xA259) || (i == 0xF9DA) || ((i >= 0xAB45) && (i <= 0xADBB)) || ((i >= 0xCDDD) && (i <= 0xD0C7)))  return 0xAB45;

  else if ((i == 0xA25A) || ((i >= 0xADBC) && (i <= 0xB0AD)) || ((i >= 0xD0C8) && (i <= 0xD44A)))  return 0xADBC;

  else if ((i == 0xA25B) || (i == 0xA25C) || ((i >= 0xB0AE) && (i <= 0xB3C2)) || ((i >= 0xD44B) && (i <= 0xD850)))  return 0xB0AE;

  else if ((i == 0xF9DB) || ((i >= 0xB3C3) && (i <= 0xB6C2)) || ((i >= 0xD851) && (i <= 0xDCB0)))  return 0xB3C3;

  else if ((i == 0xA25D) || (i == 0xA25F) || (i == 0xC6A1) || (i == 0xF9D6) || (i == 0xF9D8) || ((i >= 0xB6C3) && (i <= 0xB9AB)) || ((i >= 0xDCB1) && (i <= 0xE0EF)))  return 0xB6C3;

  else if ((i == 0xF9DC) || ((i >= 0xB9AC) && (i <= 0xBBF4)) || ((i >= 0xE0F0) && (i <= 0xE4E5)))  return 0xB9AC;

  else if ((i == 0xA261) || ((i >= 0xBBF5) && (i <= 0xBEA6)) || ((i >= 0xE4E6) && (i <= 0xE8F3)))  return 0xBBF5;

  else if ((i == 0xA25E) || (i == 0xF9D7) || (i == 0xF9D9) || ((i >= 0xBEA7) && (i <= 0xC074)) || ((i >= 0xE8F4) && (i <= 0xECB8)))  return 0xBEA7;

  else if (((i >= 0xC075) && (i <= 0xC24E)) || ((i >= 0xECB9) && (i <= 0xEFB6)))  return 0xC075;

  else if (((i >= 0xC24F) && (i <= 0xC35E)) || ((i >= 0xEFB7) && (i <= 0xF1EA)))  return 0xC24F;

  else if (((i >= 0xC35F) && (i <= 0xC454)) || ((i >= 0xF1EB) && (i <= 0xF3FC)))  return 0xC35F;

  else if (((i >= 0xC455) && (i <= 0xC4D6)) || ((i >= 0xF3FD) && (i <= 0xF5BF)))  return 0xC455;

  else if (((i >= 0xC4D7) && (i <= 0xC56A)) || ((i >= 0xF5C0) && (i <= 0xF6D5)))  return 0xC4D7;

  else if (((i >= 0xC56B) && (i <= 0xC5C7)) || ((i >= 0xF6D6) && (i <= 0xF7CF)))  return 0xC56B;

  else if (((i >= 0xC5C8) && (i <= 0xC5F0)) || ((i >= 0xF7D0) && (i <= 0xF8A4)))  return 0xC5C8;

  else if (((i >= 0xC5F1) && (i <= 0xC654)) || ((i >= 0xF8A5) && (i <= 0xF8ED)))  return 0xC5F1;

  else if (((i >= 0xC655) && (i <= 0xC664)) || ((i >= 0xF8EE) && (i <= 0xF96A)))  return 0xC655;

  else if (((i >= 0xC665) && (i <= 0xC66B)) || ((i >= 0xF96B) && (i <= 0xF9A1)))  return 0xC665;

  else if (((i >= 0xC66C) && (i <= 0xC675)) || ((i >= 0xF9A2) && (i <= 0xF9B9)))  return 0xC66C;

  else if (((i >= 0xC676) && (i <= 0xC678)) || ((i >= 0xF9BA) && (i <= 0xF9C5)))  return 0xC676;

  else if (((i >= 0xC679) && (i <= 0xC67C)) || ((i >= 0xF9C7) && (i <= 0xF9CB)))  return 0xC679;

  else if ((i == 0xC67D) || ((i >= 0xF9CC) && (i <= 0xF9CF)))  return 0xC67D;

  else if (i == 0xF9D0)  return 0xF9D0;

  else if ((i == 0xC67E) || (i == 0xF9D1))  return 0xC67E;

  else if ((i == 0xF9C6) || (i == 0xF9D2))  return 0xF9C6;

  else if (i == 0xF9D3)  return 0xF9D3;

  else if (i == 0xF9D4)  return 0xF9D4;

  else if (i == 0xF9D5)  return 0xF9D5;

  return 0xA140;

}

static int my_strnncoll_big5_internal(const uchar **a_res,

				      const uchar **b_res, size_t length)

{

  const uchar *a= *a_res, *b= *b_res;

  while (length--)

  {

    if ((length > 0) && isbig5code(*a,*(a+1)) && isbig5code(*b, *(b+1)))

    {

      if (*a != *b || *(a+1) != *(b+1))

	return ((int) big5code(*a,*(a+1)) -

		(int) big5code(*b,*(b+1)));

      a+= 2;

      b+= 2;

      length--;

    }

    else if (sort_order_big5[*a++] !=

	     sort_order_big5[*b++])

      return ((int) sort_order_big5[a[-1]] -

	      (int) sort_order_big5[b[-1]]);

  }

  *a_res= a;

  *b_res= b;

  return 0;

}

/* Compare strings */

static int my_strnncoll_big5(CHARSET_INFO *cs __attribute__((unused)), 

			     const uchar *a, size_t a_length,

                             const uchar *b, size_t b_length,

                             my_bool b_is_prefix)

{

  size_t length= min(a_length, b_length);

  int res= my_strnncoll_big5_internal(&a, &b, length);

  return res ? res : (int)((b_is_prefix ? length : a_length) - b_length);

}

/* compare strings, ignore end space */

static int my_strnncollsp_big5(CHARSET_INFO * cs __attribute__((unused)), 

			       const uchar *a, size_t a_length, 

			       const uchar *b, size_t b_length,

                               my_bool diff_if_only_endspace_difference)

{

  size_t length= min(a_length, b_length);

  int res= my_strnncoll_big5_internal(&a, &b, length);

#ifndef VARCHAR_WITH_DIFF_ENDSPACE_ARE_DIFFERENT_FOR_UNIQUE

  diff_if_only_endspace_difference= 0;

#endif

  if (!res && a_length != b_length)

  {

    const uchar *end;

    int swap= 1;

    if (diff_if_only_endspace_difference)

      res= 1;                                   /* Assume 'a' is bigger */

    /*

      Check the next not space character of the longer key. If it's < ' ',

      then it's smaller than the other key.

    */

    if (a_length < b_length)

    {

      /* put longer key in a */

      a_length= b_length;

      a= b;

      swap= -1;                                 /* swap sign of result */

      res= -res;

    }

    for (end= a + a_length-length; a < end ; a++)

    {

      if (*a != ' ')

	return (*a < ' ') ? -swap : swap;

    }

  }

  return res;

}

static size_t

my_strnxfrm_big5(CHARSET_INFO *cs,

                 uchar *dst, size_t dstlen, uint nweights,

                 const uchar *src, size_t srclen, uint flags)

{

  uchar *d0= dst;

  uchar *de= dst + dstlen;

  const uchar *se= src + srclen;

  const uchar *sort_order= cs->sort_order;

  for (; dst < de && src < se && nweights; nweights--)

  {

    if (cs->cset->ismbchar(cs, (const char*) src, (const char*) se))

    {

      /*

        Note, it is safe not to check (src < se)

        in the code below, because ismbchar() would

        not return TRUE if src was too short

      */

      uint16 e= big5strokexfrm((uint16) big5code(*src, *(src + 1)));

      *dst++= big5head(e);

      if (dst < de)

        *dst++= big5tail(e);

      src+= 2;

    }

    else

      *dst++= sort_order ? sort_order[*src++] : *src++;

  }

  return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, de, nweights, flags, 0);

}

/*

** Calculate min_str and max_str that ranges a LIKE string.

** Arguments:

** ptr		Pointer to LIKE string.

** ptr_length	Length of LIKE string.

** escape	Escape character in LIKE.  (Normally '\').

**		All escape characters should be removed from min_str and max_str

** res_length   Length of min_str and max_str.

** min_str      Smallest case sensitive string that ranges LIKE.

**		Should be space padded to res_length.

** max_str	Largest case sensitive string that ranges LIKE.

**		Normally padded with the biggest character sort value.

**

** The function should return 0 if ok and 1 if the LIKE string can't be

** optimized !

*/

#define max_sort_char ((char) 255)

static my_bool my_like_range_big5(CHARSET_INFO *cs __attribute__((unused)),

				  const char *ptr,size_t ptr_length,

				  pbool escape, pbool w_one, pbool w_many,

				  size_t res_length,

                                  char *min_str, char *max_str,

				  size_t *min_length, size_t *max_length)

{

  const char *end= ptr + ptr_length;

  char *min_org=min_str;

  char *min_end=min_str+res_length;

  size_t charlen= res_length / cs->mbmaxlen;

  for (; ptr != end && min_str != min_end && charlen > 0; ptr++, charlen--)

  {

    if (ptr+1 != end && isbig5code(ptr[0],ptr[1]))

    {

      *min_str++= *max_str++ = *ptr++;

      *min_str++= *max_str++ = *ptr;

      continue;

    }

    if (*ptr == escape && ptr+1 != end)

    {

      ptr++;				/* Skip escape */

      if (isbig5code(ptr[0], ptr[1]))

        *min_str++= *max_str++ = *ptr++;

      if (min_str < min_end)

        *min_str++= *max_str++= *ptr;

      continue;

    }

    if (*ptr == w_one)			/* '_' in SQL */

    {

      *min_str++='\0';			/* This should be min char */

      *max_str++=max_sort_char;

      continue;

    }

    if (*ptr == w_many)		/* '%' in SQL */

    {

      /*

        Calculate length of keys:

        'a\0\0... is the smallest possible string when we have space expand

        a\ff\ff... is the biggest possible string

      */

      *min_length= ((cs->state & MY_CS_BINSORT) ? (size_t) (min_str - min_org) :

                    res_length);

      *max_length= res_length;

      do {

	*min_str++ = 0;

	*max_str++ = max_sort_char;

      } while (min_str != min_end);

      return 0;

    }

    *min_str++= *max_str++ = *ptr;

  }

 *min_length= *max_length= (size_t) (min_str-min_org);

  while (min_str != min_end)

    *min_str++= *max_str++= ' ';

  return 0;

}

static uint ismbchar_big5(CHARSET_INFO *cs __attribute__((unused)),

                         const char* p, const char *e)

{

  return (isbig5head(*(p)) && (e)-(p)>1 && isbig5tail(*((p)+1))? 2: 0);

}

static uint mbcharlen_big5(CHARSET_INFO *cs __attribute__((unused)), uint c)

{

  return (isbig5head(c)? 2 : 1);

}

/* page 0 0xA140-0xC7FC */

static uint16 tab_big5_uni0[]={

0x3000,0xFF0C,0x3001,0x3002,0xFF0E,0x2022,0xFF1B,0xFF1A,

0xFF1F,0xFF01,0xFE30,0x2026,0x2025,0xFE50,0xFF64,0xFE52,

0x00B7,0xFE54,0xFE55,0xFE56,0xFE57,0xFF5C,0x2013,0xFE31,

0x2014,0xFE33,0xFFFD,0xFE34,0xFE4F,0xFF08,0xFF09,0xFE35,

0xFE36,0xFF5B,0xFF5D,0xFE37,0xFE38,0x3014,0x3015,0xFE39,

0xFE3A,0x3010,0x3011,0xFE3B,0xFE3C,0x300A,0x300B,0xFE3D,

0xFE3E,0x3008,0x3009,0xFE3F,0xFE40,0x300C,0x300D,0xFE41,

0xFE42,0x300E,0x300F,0xFE43,0xFE44,0xFE59,0xFE5A,     0,

     0,     0,     0,     0,     0,     0,     0,     0,

     0,     0,     0,     0,     0,     0,     0,     0,

     0,     0,     0,     0,     0,     0,     0,     0,

     0,     0,     0,     0,     0,     0,     0,     0,

     0,0xFE5B,0xFE5C,0xFE5D,0xFE5E,0x2018,0x2019,0x201C,

0x201D,0x301D,0x301E,0x2035,0x2032,0xFF03,0xFF06,0xFF0A,

0x203B,0x00A7,0x3003,0x25CB,0x25CF,0x25B3,0x25B2,0x25CE,

0x2606,0x2605,0x25C7,0x25C6,0x25A1,0x25A0,0x25BD,0x25BC,

0x32A3,0x2105,0x203E,0xFFFD,0xFF3F,0xFFFD,0xFE49,0xFE4A,

0xFE4D,0xFE4E,0xFE4B,0xFE4C,0xFE5F,0xFE60,0xFE61,0xFF0B,