From 68375e0f008d109f574491bd3b0eb2184e6f3ad2 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Tue, 12 Mar 2002 21:37:58 +0400
Subject: New ctype functions/macros to support many charsets at a time

client/mysql.cc:
  new ctypes
client/mysqldump.c:
  new ctypes
client/mysqltest.c:
  new ctypes
client/sql_string.cc:
  new ctypes
client/sql_string.h:
  new ctypes
extra/mysql_install.c:
  new ctypes
extra/replace.c:
  new ctypes
extra/resolve_stack_dump.c:
  new ctypes
extra/resolveip.c:
  new ctypes
heap/hp_hash.c:
  new ctypes
include/m_ctype.h:
  new ctypes
include/my_sys.h:
  new ctypes
isam/_key.c:
  new ctypes
isam/_search.c:
  new ctypes
libmysql/Makefile.shared:
  new ctypes
libmysql/libmysql.c:
  new ctypes
myisam/ft_dump.c:
  new ctypes
myisam/ft_parser.c:
  new ctypes
myisam/mi_test1.c:
  new ctypes
mysys/charset.c:
  new ctypes
mysys/default.c:
  new ctypes
mysys/getvar.c:
  new ctypes
mysys/hash.c:
  new ctypes
mysys/mf_casecnv.c:
  new ctypes
mysys/mf_dirname.c:
  new ctypes
mysys/mf_format.c:
  new ctypes
mysys/mf_iocache2.c:
  new ctypes
mysys/mf_soundex.c:
  new ctypes
mysys/mf_wfile.c:
  new ctypes
mysys/my_error.c:
  new ctypes
mysys/my_getwd.c:
  new ctypes
mysys/my_init.c:
  new ctypes
mysys/my_vsnprintf.c:
  new ctypes
mysys/typelib.c:
  new ctypes
sql/convert.cc:
  new ctypes
sql/des_key_file.cc:
  new ctypes
sql/field.cc:
  new ctypes
sql/field.h:
  new ctypes
sql/field_conv.cc:
  new ctypes
sql/filesort.cc:
  new ctypes
sql/ha_innodb.cc:
  new ctypes
sql/hostname.cc:
  new ctypes
sql/init.cc:
  new ctypes
sql/item.cc:
  new ctypes
sql/item_func.cc:
  new ctypes
sql/item_strfunc.cc:
  new ctypes
sql/item_sum.cc:
  new ctypes
sql/item_timefunc.cc:
  new ctypes
sql/key.cc:
  new ctypes
sql/log.cc:
  new ctypes
sql/mysql_priv.h:
  new ctypes
sql/mysqld.cc:
  new ctypes
sql/opt_range.cc:
  new ctypes
sql/procedure.cc:
  new ctypes
sql/slave.cc:
  new ctypes
sql/sql_acl.cc:
  new ctypes
sql/sql_analyse.cc:
  new ctypes
sql/sql_base.cc:
  new ctypes
sql/sql_cache.cc:
  new ctypes
sql/sql_db.cc:
  new ctypes
sql/sql_handler.cc:
  new ctypes
sql/sql_lex.cc:
  new ctypes
sql/sql_parse.cc:
  new ctypes
sql/sql_show.cc:
  new ctypes
sql/sql_string.cc:
  new ctypes
sql/sql_string.h:
  new ctypes
sql/sql_table.cc:
  new ctypes
sql/sql_yacc.yy:
  new ctypes
sql/table.cc:
  new ctypes
sql/time.cc:
  new ctypes
strings/Makefile.am:
  new ctypes
strings/ctype-big5.c:
  new ctypes
strings/ctype-czech.c:
  new ctypes
strings/ctype-gbk.c:
  new ctypes
strings/ctype-latin1_de.c:
  new ctypes
strings/ctype-sjis.c:
  new ctypes
strings/ctype-tis620.c:
  new ctypes
strings/ctype.c:
  new ctypes
strings/str2int.c:
  new ctypes
strings/strto.c:
  new ctypes
tools/mysqlmanager.c:
  new ctypes
---
 mysys/charset.c      |   8 +-
 mysys/default.c      |  10 +--
 mysys/getvar.c       |   9 ++-
 mysys/hash.c         |   7 +-
 mysys/mf_casecnv.c   | 216 ++++-----------------------------------------------
 mysys/mf_dirname.c   |   6 --
 mysys/mf_format.c    |   6 --
 mysys/mf_iocache2.c  |   2 +-
 mysys/mf_soundex.c   |  20 ++---
 mysys/mf_wfile.c     |   7 --
 mysys/my_error.c     |   2 +-
 mysys/my_getwd.c     |   3 +-
 mysys/my_init.c      |   3 +-
 mysys/my_vsnprintf.c |   2 +-
 mysys/typelib.c      |   4 +-
 15 files changed, 53 insertions(+), 252 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 93e8b697904..1d84bb67d68 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -68,7 +68,7 @@ static my_bool get_word(struct simpleconfig_buf_st *fb, char *buf)
 
   for (;;)
   {
-    while (isspace(*endptr))
+    while (my_isspace(system_charset_info, *endptr))
       ++endptr;
     if (*endptr && *endptr != '#')		/* Not comment */
       break;					/* Found something */
@@ -77,7 +77,7 @@ static my_bool get_word(struct simpleconfig_buf_st *fb, char *buf)
     endptr = fb->buf;
   }
 
-  while (!isspace(*endptr))
+  while (!my_isspace(system_charset_info, *endptr))
     *buf++= *endptr++;
   *buf=0;
   fb->p = endptr;
@@ -540,11 +540,9 @@ void _print_csinfo(CHARSET_INFO *cs)
   printf("to_lower:\n"); _print_array(cs->to_lower, 256);
   printf("to_upper:\n"); _print_array(cs->to_upper, 256);
   printf("sort_order:\n"); _print_array(cs->sort_order, 256);
-  printf("collate:    %3s (%d, %p, %p, %p, %p, %p)\n",
+  printf("collate:    %3s (%d, %p, %p, %p)\n",
          cs->strxfrm_multiply ? "yes" : "no",
          cs->strxfrm_multiply,
-         cs->strcoll,
-         cs->strxfrm,
          cs->strnncoll,
          cs->strnxfrm,
          cs->like_range);
diff --git a/mysys/default.c b/mysys/default.c
index d3c1b3815eb..ad34d4b949d 100644
--- a/mysys/default.c
+++ b/mysys/default.c
@@ -247,7 +247,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
   {
     line++;
     /* Ignore comment and empty lines */
-    for (ptr=buff ; isspace(*ptr) ; ptr++ ) ;
+    for (ptr=buff ; my_isspace(system_charset_info,*ptr) ; ptr++ ) ;
     if (*ptr == '#' || *ptr == ';' || !*ptr)
       continue;
     if (*ptr == '[')				/* Group name */
@@ -260,7 +260,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
 		name,line);
 	goto err;
       }
-      for ( ; isspace(end[-1]) ; end--) ;	/* Remove end space */
+      for ( ; my_isspace(system_charset_info,end[-1]) ; end--) ;/* Remove end space */
       end[0]=0;
       read_values=find_type(ptr,group,3) > 0;
       continue;
@@ -276,7 +276,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
       continue;
     if (!(end=value=strchr(ptr,'=')))
       end=strend(ptr);				/* Option without argument */
-    for ( ; isspace(end[-1]) ; end--) ;
+    for ( ; my_isspace(system_charset_info,end[-1]) ; end--) ;
     if (!value)
     {
       if (!(tmp=alloc_root(alloc,(uint) (end-ptr)+3)))
@@ -289,9 +289,9 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
     {
       /* Remove pre- and end space */
       char *value_end;
-      for (value++ ; isspace(*value); value++) ;
+      for (value++ ; my_isspace(system_charset_info,*value); value++) ;
       value_end=strend(value);
-      for ( ; isspace(value_end[-1]) ; value_end--) ;
+      for ( ; my_isspace(system_charset_info,value_end[-1]) ; value_end--) ;
       if (value_end < value)			/* Empty string */
 	value_end=value;
       if (!(tmp=alloc_root(alloc,(uint) (end-ptr)+3 +
diff --git a/mysys/getvar.c b/mysys/getvar.c
index bb470423c57..b5cc123f4b4 100644
--- a/mysys/getvar.c
+++ b/mysys/getvar.c
@@ -58,14 +58,15 @@ my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
       longlong num;
 
       /* Skip end space from variable */
-      for (var_end=end ; end > str && isspace(var_end[-1]) ; var_end--) ;
+      for (var_end=end ; end > str && my_isspace(system_charset_info, var_end[-1]) ; var_end--) ;
       length=(uint) (var_end-str);
       /* Skip start space from argument */
-      for (end++ ; isspace(*end) ; end++) ;
+      for (end++ ; my_isspace(system_charset_info, *end) ; end++) ;
 
       for (var=vars,found=0 ; (name=var->name) ; var++)
       {
-	if (!my_casecmp(name,str,length))
+        /* BAR TODO: remove system_charset_info */
+	if (!my_strncasecmp(system_charset_info,name,str,length))
 	{
 	  found=var; found_count++;
 	  if (!name[length])
@@ -93,7 +94,7 @@ my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
 	num*=1024L*1024L;
       else if (endchar == 'g' || endchar == 'G')
 	num*=1024L*1024L*1024L;
-      else if (!isdigit(endchar))
+      else if (!my_isdigit(system_charset_info, endchar))
       {
 	fprintf(stderr,"Unknown prefix used for variable value '%s'\n",str);
 	DBUG_RETURN(1);
diff --git a/mysys/hash.c b/mysys/hash.c
index 0b326ebc508..f1ce5052e4f 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -129,7 +129,9 @@ static uint calc_hashnr_caseup(const byte *key,uint length)
   register uint nr=1, nr2=4;
   while (length--)
   {
-    nr^= (((nr & 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr << 8);
+    /* BAR TODO: remove default_charset_info */
+    nr^= (((nr & 63)+nr2)*
+         ((uint) (uchar) my_toupper(default_charset_info, *key++)))+ (nr << 8);
     nr2+=3;
   }
   return((uint) nr);
@@ -271,9 +273,10 @@ static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
 {
   uint rec_keylength;
   byte *rec_key=hash_key(hash,pos->data,&rec_keylength,1);
+  /* BAR TODO: remove default_charset_info */
   return (length && length != rec_keylength) ||
     (hash->flags & HASH_CASE_INSENSITIVE ?
-     my_casecmp(rec_key,key,rec_keylength) :
+     my_strncasecmp(default_charset_info, rec_key,key,rec_keylength) :
      memcmp(rec_key,key,rec_keylength));
 }
 
diff --git a/mysys/mf_casecnv.c b/mysys/mf_casecnv.c
index 0302688ad1f..510a9b08f76 100644
--- a/mysys/mf_casecnv.c
+++ b/mysys/mf_casecnv.c
@@ -28,234 +28,50 @@
 #include <m_string.h>
 #endif
 
-	/* string to uppercase */
-
-void caseup_str(my_string str)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register char *end=str+strlen(str);
-    while (*str)
-    {
-      if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
-      else *str=toupper(*str),++str;
-    }
-  }
-  else
-#endif
-    while ((*str = toupper(*str)) != 0)
-      str++;
-} /* caseup_str */
-
-	/* string to lowercase */
-
-void casedn_str(my_string str)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register char *end=str+strlen(str);
-    while (*str)
-    {
-      if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
-      else *str=tolower(*str),++str;
-    }
-  }
-  else
-#endif
-    while ((*str= tolower(*str)) != 0)
-      str++;
-} /* casedn_str */
-
-
-	/* to uppercase */
-
-void caseup(my_string str, uint length)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register char *end=str+length;
-    while (str<end)
-    {
-      if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
-      else *str=toupper(*str),++str;
-    }
-  }
-  else
-#endif
-    for ( ; length>0 ; length--, str++)
-      *str= toupper(*str);
-} /* caseup */
-
-	/* to lowercase */
-
-void casedn(my_string str, uint length)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register char *end=str+length;
-    while (str<end)
-    {
-      if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
-      else *str=tolower(*str),++str;
-    }
-  }
-  else
-#endif
-    for ( ; length>0 ; length--, str++)
-      *str= tolower(*str);
-} /* casedn */
 
 	/* to sort-string that can be compared to get text in order */
 
-void case_sort(my_string str, uint length)
+void case_sort(CHARSET_INFO *cs, my_string str, uint length)
 {
   for ( ; length>0 ; length--, str++)
-    *str= (char) my_sort_order[(uchar) *str];
+    *str= (char) cs->sort_order[(uchar) *str];
 } /* case_sort */
 
-	/* find string in another with no case_sensivity */
-
-/* ToDo: This function should be modified to support multibyte charset.
-         However it is not used untill 3.23.5.
-	 Wei He (hewei@mail.ied.ac.cn)
-*/
-
-my_string my_strcasestr(const char *str, const char *search)
-{
- uchar *i,*j,*pos;
-
- pos=(uchar*) str;
-skipp:
- while (*pos != '\0')
- {
-   if (toupper((uchar) *pos++) == toupper((uchar) *search))
-   {
-     i=(uchar*) pos; j=(uchar*) search+1;
-     while (*j)
-       if (toupper(*i++) != toupper(*j++)) goto skipp;
-     return ((char*) pos-1);
-   }
- }
- return ((my_string) 0);
-} /* strcstr */
-
-
-	/* compare strings without regarding to case */
-
-int my_strcasecmp(const char *s, const char *t)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register const char *end=s+strlen(s);
-    while (s<end)
-    {
-      if ((l=my_ismbchar(default_charset_info, s,end)))
-      {
-        while (l--)
-          if (*s++ != *t++) return 1;
-      }
-      else if (my_ismbhead(default_charset_info, *t)) return 1;
-      else if (toupper((uchar) *s++) != toupper((uchar) *t++)) return 1;
-    }
-    return *t;
-  }
-  else
-#endif
-  {
-    while (toupper((uchar) *s) == toupper((uchar) *t++))
-      if (!*s++) return 0;
-    return ((int) toupper((uchar) s[0]) - (int) toupper((uchar) t[-1]));
-  }
-}
-
-
-int my_casecmp(const char *s, const char *t, uint len)
-{
-#ifdef USE_MB
-  if (use_mb(default_charset_info))
-  {
-    register uint32 l;
-    register const char *end=s+len;
-    while (s<end)
-    {
-      if ((l=my_ismbchar(default_charset_info, s,end)))
-      {
-        while (l--)
-          if (*s++ != *t++) return 1;
-      }
-      else if (my_ismbhead(default_charset_info, *t)) return 1;
-      else if (toupper((uchar) *s++) != toupper((uchar) *t++)) return 1;
-    }
-    return 0;
-  }
-  else
-#endif
-  {
-    while (len-- != 0 && toupper(*s++) == toupper(*t++)) ;
-    return (int) len+1;
-  }
-}
-
-
-int my_strsortcmp(const char *s, const char *t)
-{
-#ifdef USE_STRCOLL
-  if (use_strcoll(default_charset_info))
-    return my_strcoll(default_charset_info, (uchar *)s, (uchar *)t);
-  else
-#endif
-  {
-    while (my_sort_order[(uchar) *s] == my_sort_order[(uchar) *t++])
-      if (!*s++) return 0;
-    return ((int) my_sort_order[(uchar) s[0]] -
-            (int) my_sort_order[(uchar) t[-1]]);
-  }
-}
 
-int my_sortcmp(const char *s, const char *t, uint len)
+int my_sortcmp(CHARSET_INFO *cs, const char *s, const char *t, uint len)
 {
 #ifdef USE_STRCOLL
-  if (use_strcoll(default_charset_info))
-    return my_strnncoll(default_charset_info,
-                        (uchar *)s, len, (uchar *)t, len);
+  if (use_strcoll(cs))
+    return my_strnncoll(cs,(uchar *)s, len, (uchar *)t, len);
   else
 #endif
   {
     while (len--)
     {
-      if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
-        return ((int) my_sort_order[(uchar) s[-1]] -
-                (int) my_sort_order[(uchar) t[-1]]);
+      if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
+        return ((int) cs->sort_order[(uchar) s[-1]] -
+                (int) cs->sort_order[(uchar) t[-1]]);
     }
     return 0;
   }
 }
 
-int my_sortncmp(const char *s, uint s_len, const char *t, uint t_len)
+int my_sortncmp(CHARSET_INFO *cs,
+                const char *s, uint s_len, 
+                const char *t, uint t_len)
 {
 #ifdef USE_STRCOLL
-  if (use_strcoll(default_charset_info))
-    return my_strnncoll(default_charset_info,
-                        (uchar *)s, s_len, (uchar *)t, t_len);
+  if (use_strcoll(cs))
+    return my_strnncoll(cs, (uchar *)s, s_len, (uchar *)t, t_len);
   else
 #endif
   {
     uint len= min(s_len,t_len);
     while (len--)
     {
-      if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
-        return ((int) my_sort_order[(uchar) s[-1]] -
-                (int) my_sort_order[(uchar) t[-1]]);
+      if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
+        return ((int) cs->sort_order[(uchar) s[-1]] -
+                (int) cs->sort_order[(uchar) t[-1]]);
     }
     return (int) (s_len - t_len);
   }
diff --git a/mysys/mf_dirname.c b/mysys/mf_dirname.c
index 6523abcdb12..320917c8f3e 100644
--- a/mysys/mf_dirname.c
+++ b/mysys/mf_dirname.c
@@ -108,11 +108,5 @@ char *convert_dirname(char *to, const char *from, const char *from_end)
     *to++=FN_LIBCHAR;
     *to=0;
   }
-#ifdef FN_UPPER_CASE
-  caseup_str(to_org);
-#endif
-#ifdef FN_LOWER_CASE
-  casedn_str(to_org);
-#endif
   return to;					/* Pointer to end of dir */
 } /* convert_dirname */
diff --git a/mysys/mf_format.c b/mysys/mf_format.c
index ab1904da162..e68f7df9d83 100644
--- a/mysys/mf_format.c
+++ b/mysys/mf_format.c
@@ -91,12 +91,6 @@ my_string fn_format(my_string to, const char *name, const char *dir,
       name=buff;
     }
     pos=strmake(strmov(to,dev),name,length);
-#ifdef FN_UPPER_CASE
-    caseup_str(to);
-#endif
-#ifdef FN_LOWER_CASE
-    casedn_str(to);
-#endif
     (void) strmov(pos,ext);			/* Don't convert extension */
   }
   /*
diff --git a/mysys/mf_iocache2.c b/mysys/mf_iocache2.c
index 127bf20e8fe..147850a10bc 100644
--- a/mysys/mf_iocache2.c
+++ b/mysys/mf_iocache2.c
@@ -249,7 +249,7 @@ uint my_b_vprintf(IO_CACHE *info, const char* fmt, va_list args)
       /* Found one '%' */
     }
     /* Skipp if max size is used (to be compatible with printf) */
-    while (isdigit(*fmt) || *fmt == '.' || *fmt == '-')
+    while (my_isdigit(system_charset_info, *fmt) || *fmt == '.' || *fmt == '-')
       fmt++;
     if (*fmt == 's')				/* String parameter */
     {
diff --git a/mysys/mf_soundex.c b/mysys/mf_soundex.c
index 4f7aa7da601..8ecd95137b0 100644
--- a/mysys/mf_soundex.c
+++ b/mysys/mf_soundex.c
@@ -34,12 +34,12 @@
 #include <m_ctype.h>
 #include "my_static.h"
 
-static char get_scode(char **ptr,pbool remove_garbage);
+static char get_scode(CHARSET_INFO * cs, char **ptr,pbool remove_garbage);
 
 		/* outputed string is 4 byte long */
 		/* out_pntr can be == in_pntr */
 
-void soundex(register my_string out_pntr, my_string in_pntr,
+void soundex(CHARSET_INFO * cs,register my_string out_pntr, my_string in_pntr,
 	     pbool remove_garbage)
 {
   char ch,last_ch;
@@ -47,11 +47,11 @@ void soundex(register my_string out_pntr, my_string in_pntr,
 
   if (remove_garbage)
   {
-    while (*in_pntr && isspace(*in_pntr))	/* Skipp pre-space */
+    while (*in_pntr && my_isspace(cs,*in_pntr))	/* Skipp pre-space */
       in_pntr++;
   }
-  *out_pntr++ = toupper(*in_pntr);	/* Copy first letter		 */
-  last_ch = get_scode(&in_pntr,0);	/* code of the first letter	 */
+  *out_pntr++ = my_toupper(cs,*in_pntr);/* Copy first letter		 */
+  last_ch = get_scode(cs,&in_pntr,0);	/* code of the first letter	 */
 					/* for the first 'double-letter  */
 					/* check.			 */
   end=out_pntr+3;			/* Loop on input letters until	 */
@@ -59,7 +59,7 @@ void soundex(register my_string out_pntr, my_string in_pntr,
 					/* letter code count = 3	 */
 
   in_pntr++;
-  while (out_pntr < end && (ch = get_scode(&in_pntr,remove_garbage)) != 0)
+  while (out_pntr < end && (ch = get_scode(cs,&in_pntr,remove_garbage)) != 0)
   {
     in_pntr++;
     if ((ch != '0') && (ch != last_ch)) /* if not skipped or double */
@@ -81,19 +81,19 @@ void soundex(register my_string out_pntr, my_string in_pntr,
     else return 0
     */
 
-static char get_scode(char **ptr, pbool remove_garbage)
+static char get_scode(CHARSET_INFO * cs,char **ptr, pbool remove_garbage)
 {
   uchar ch;
 
   if (remove_garbage)
   {
-    while (**ptr && !isalpha(**ptr))
+    while (**ptr && !my_isalpha(cs,**ptr))
       (*ptr)++;
   }
-  ch=toupper(**ptr);
+  ch=my_toupper(cs,**ptr);
   if (ch < 'A' || ch > 'Z')
   {
-    if (isalpha(ch))			/* If exetended alfa (country spec) */
+    if (my_isalpha(cs,ch))		/* If exetended alfa (country spec) */
       return '0';			/* threat as vokal */
     return 0;				/* Can't map */
   }
diff --git a/mysys/mf_wfile.c b/mysys/mf_wfile.c
index e9e12c72755..3c10de1f238 100644
--- a/mysys/mf_wfile.c
+++ b/mysys/mf_wfile.c
@@ -54,13 +54,6 @@ WF_PACK *wf_comp(my_string str)
   for (pos=str ; *pos ; pos++)
     ant+= test(*pos == ' ' || *pos == ',');
 
-#ifdef FN_UPPER_CASE
-    caseup(str,(int) (pos-str));
-#endif
-#ifdef FN_LOWER_CASE
-    casedn(str,(int) (pos-str));
-#endif
-
   if ((ret= (WF_PACK*) my_malloc((uint) ant*(sizeof(my_string*)+2)+
 				 sizeof(WF_PACK)+ (uint) strlen(str)+1,
 				 MYF(MY_WME)))
diff --git a/mysys/my_error.c b/mysys/my_error.c
index 61f8c16aba5..fd0cdcc2289 100644
--- a/mysys/my_error.c
+++ b/mysys/my_error.c
@@ -62,7 +62,7 @@ int my_error(int nr,myf MyFlags, ...)
     else
     {
       /* Skipp if max size is used (to be compatible with printf) */
-      while (isdigit(*tpos) || *tpos == '.' || *tpos == '-')
+      while (my_isdigit(system_charset_info, *tpos) || *tpos == '.' || *tpos == '-')
 	tpos++;
       if (*tpos == 'l')				/* Skipp 'l' argument */
 	tpos++;
diff --git a/mysys/my_getwd.c b/mysys/my_getwd.c
index 22c6a4dbc2b..240b17ef87f 100644
--- a/mysys/my_getwd.c
+++ b/mysys/my_getwd.c
@@ -109,7 +109,8 @@ int my_setwd(const char *dir, myf MyFlags)
     uint drive,drives;
 
     pos++;				/* Skipp FN_DEVCHAR */
-    drive=(uint) (toupper(dir[0])-'A'+1); drives= (uint) -1;
+    drive=(uint) (my_toupper(system_charset_info,dir[0])-'A'+1);
+    drives= (uint) -1;
     if ((pos-(byte*) dir) == 2 && drive > 0 && drive < 32)
     {
 #ifdef OS2
diff --git a/mysys/my_init.c b/mysys/my_init.c
index c4e6132aa9c..faf4e7f83f0 100644
--- a/mysys/my_init.c
+++ b/mysys/my_init.c
@@ -17,7 +17,6 @@
 #include "mysys_priv.h"
 #include "my_static.h"
 #include "mysys_err.h"
-#include "m_ctype.h"
 #include <m_string.h>
 #include <m_ctype.h>
 #ifdef THREAD
@@ -50,7 +49,7 @@ my_bool my_init_done=0;
 static ulong atoi_octal(const char *str)
 {
   long int tmp;
-  while (*str && isspace(*str))
+  while (*str && my_isspace(system_charset_info, *str))
     str++;
   str2int(str,
 	  (*str == '0' ? 8 : 10),		/* Octalt or decimalt */
diff --git a/mysys/my_vsnprintf.c b/mysys/my_vsnprintf.c
index 0fe6eff24a6..519faa1de03 100644
--- a/mysys/my_vsnprintf.c
+++ b/mysys/my_vsnprintf.c
@@ -41,7 +41,7 @@ int my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap)
     }
     /* Skipp if max size is used (to be compatible with printf) */
     fmt++;
-    while (isdigit(*fmt) || *fmt == '.' || *fmt == '-')
+    while (my_isdigit(system_charset_info,*fmt) || *fmt == '.' || *fmt == '-')
       fmt++;
     if (*fmt == 'l')
       fmt++;
diff --git a/mysys/typelib.c b/mysys/typelib.c
index e2c8eade5c8..e524f903b5d 100644
--- a/mysys/typelib.c
+++ b/mysys/typelib.c
@@ -47,7 +47,9 @@ int find_type(my_string x, TYPELIB *typelib, uint full_name)
   find=0;
   for (pos=0 ; (j=typelib->type_names[pos]) ; pos++)
   {
-    for (i=x ; *i && toupper(*i) == toupper(*j) ; i++, j++) ;
+    for (i=x ; 
+    	*i && my_toupper(system_charset_info,*i) == 
+    		my_toupper(system_charset_info,*j) ; i++, j++) ;
     if (! *j)
     {
       while (*i == ' ')
-- 
cgit v1.2.1


From ee1ef8c58c9df9a62f7a0cc3dee6c2f705c8eb44 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Thu, 14 Mar 2002 20:52:48 +0400
Subject: use String->charset instead of default_charset_info

client/mysql.cc:
  default_charset_info -> system_charset_info
include/m_ctype.h:
  Remove old ctype
mysys/charset.c:
  Initialize fields after dynamic charset loading
sql/sql_parse.cc:
  default_charset_info -> system_charset_info
---
 mysys/charset.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 1d84bb67d68..de6ccbf7ea9 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -329,6 +329,14 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   memcpy((char*) cs->to_upper, (char*) tmp_to_upper,	sizeof(tmp_to_upper));
   memcpy((char*) cs->sort_order, (char*) tmp_sort_order,
 	 sizeof(tmp_sort_order));
+
+  cs->caseup_str  = my_caseup_str_8bit;
+  cs->casedn_str  = my_casedn_str_8bit;
+  cs->caseup      = my_caseup_8bit;
+  cs->casedn      = my_casedn_8bit;
+  cs->strcasecmp  = my_strcasecmp_8bit;
+  cs->strncasecmp = my_strncasecmp_8bit;
+  
   insert_dynamic(&cs_info_table, (gptr) &cs);
   return cs;
 }
@@ -396,6 +404,7 @@ my_bool set_default_charset(uint cs, myf flags)
     DBUG_RETURN(TRUE);   /* error */
   }
   default_charset_info = new_charset;
+  system_charset_info = new_charset;
   DBUG_RETURN(FALSE);
 }
 
@@ -428,6 +437,7 @@ my_bool set_default_charset_by_name(const char *cs_name, myf flags)
   }
 
   default_charset_info = new_charset;
+  system_charset_info = new_charset;
   DBUG_RETURN(FALSE);
 }
 
-- 
cgit v1.2.1


From 8959b690fe796a44ddda440290b3fe9a9cf89ca5 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Thu, 14 Mar 2002 21:44:42 +0400
Subject: Hash now supports several charsets

---
 mysys/hash.c | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index f1ce5052e4f..41ebe59c2de 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -31,12 +31,13 @@
 
 static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
 static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
-static uint calc_hashnr(const byte *key,uint length);
-static uint calc_hashnr_caseup(const byte *key,uint length);
+static uint calc_hashnr(CHARSET_INFO *cs,const byte *key,uint length);
+static uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key,uint length);
 static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
 
 
-my_bool hash_init(HASH *hash,uint size,uint key_offset,uint key_length,
+my_bool hash_init(HASH *hash,CHARSET_INFO *charset,
+		  uint size,uint key_offset,uint key_length,
 		  hash_get_key get_key,
 		  void (*free_element)(void*),uint flags)
 {
@@ -56,6 +57,7 @@ my_bool hash_init(HASH *hash,uint size,uint key_offset,uint key_length,
   hash->get_key=get_key;
   hash->free=free_element;
   hash->flags=flags;
+  hash->charset=charset;
   if (flags & HASH_CASE_INSENSITIVE)
     hash->calc_hashnr=calc_hashnr_caseup;
   else
@@ -104,14 +106,15 @@ static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
 {
   uint length;
   byte *key=hash_key(hash,pos->data,&length,0);
-  return hash_mask((*hash->calc_hashnr)(key,length),buffmax,maxlength);
+  return hash_mask((*hash->calc_hashnr)(hash->charset,key,length),
+  		   buffmax,maxlength);
 }
 
 #ifndef NEW_HASH_FUNCTION
 
 	/* Calc hashvalue for a key */
 
-static uint calc_hashnr(const byte *key,uint length)
+static uint calc_hashnr(CHARSET_INFO *cs, const byte *key,uint length)
 {
   register uint nr=1, nr2=4;
   while (length--)
@@ -124,14 +127,13 @@ static uint calc_hashnr(const byte *key,uint length)
 
 	/* Calc hashvalue for a key, case indepenently */
 
-static uint calc_hashnr_caseup(const byte *key,uint length)
+static uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key,uint length)
 {
   register uint nr=1, nr2=4;
   while (length--)
   {
-    /* BAR TODO: remove default_charset_info */
     nr^= (((nr & 63)+nr2)*
-         ((uint) (uchar) my_toupper(default_charset_info, *key++)))+ (nr << 8);
+         ((uint) (uchar) my_toupper(cs, *key++)))+ (nr << 8);
     nr2+=3;
   }
   return((uint) nr);
@@ -152,7 +154,7 @@ static uint calc_hashnr_caseup(const byte *key,uint length)
  * This works well on both numbers and strings.
  */
 
-uint calc_hashnr(const byte *key, uint len)
+uint calc_hashnr(CHARSET_INFO *cs, const byte *key, uint len)
 {
   const byte *end=key+len;
   uint hash;
@@ -164,14 +166,14 @@ uint calc_hashnr(const byte *key, uint len)
   return (hash);
 }
 
-uint calc_hashnr_caseup(const byte *key, uint len)
+uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key, uint len)
 {
   const byte *end=key+len;
   uint hash;
   for (hash = 0; key < end; key++)
   {
     hash *= 16777619;
-    hash ^= (uint) (uchar) toupper(*key);
+    hash ^= (uint) (uchar) my_toupper(cs,*key);
   }
   return (hash);
 }
@@ -186,7 +188,7 @@ uint rec_hashnr(HASH *hash,const byte *record)
 {
   uint length;
   byte *key=hash_key(hash,record,&length,0);
-  return (*hash->calc_hashnr)(key,length);
+  return (*hash->calc_hashnr)(hash->charset,key,length);
 }
 
 
@@ -202,7 +204,7 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
   flag=1;
   if (hash->records)
   {
-    idx=hash_mask((*hash->calc_hashnr)(key,length ? length :
+    idx=hash_mask((*hash->calc_hashnr)(hash->charset,key,length ? length :
 					 hash->key_length),
 		    hash->blength,hash->records);
     do
@@ -516,7 +518,7 @@ my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
 
   /* Search after record with key */
 
-  idx=hash_mask((*hash->calc_hashnr)(old_key,(old_key_length ?
+  idx=hash_mask((*hash->calc_hashnr)(hash->charset, old_key,(old_key_length ?
 					      old_key_length :
 					      hash->key_length)),
 		  blength,records);
-- 
cgit v1.2.1


From 9a0253ffb2ce1a5a79ded187004e8fa142bb1d25 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Thu, 14 Mar 2002 22:10:56 +0400
Subject: Removed some default_charset_info

---
 mysys/hash.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index 41ebe59c2de..3faaff1f169 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -275,10 +275,9 @@ static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
 {
   uint rec_keylength;
   byte *rec_key=hash_key(hash,pos->data,&rec_keylength,1);
-  /* BAR TODO: remove default_charset_info */
   return (length && length != rec_keylength) ||
     (hash->flags & HASH_CASE_INSENSITIVE ?
-     my_strncasecmp(default_charset_info, rec_key,key,rec_keylength) :
+     my_strncasecmp(hash->charset, rec_key,key,rec_keylength) :
      memcmp(rec_key,key,rec_keylength));
 }
 
-- 
cgit v1.2.1


From 4fd893e5d3a0ff652ab21dcdb748f7aad4d7ebdf Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Fri, 29 Mar 2002 16:06:06 +0400
Subject: charset<->unicode conversion tables and routines some warnings fixes

include/m_ctype.h:
  New charset conversion fields in CHARSET_INFO
mysys/hash.c:
  Fix for "unused argument" warning
strings/ctype-big5.c:
  Fix for "unused argument" warning
strings/ctype-czech.c:
  Fix for "unused argument" warning
strings/ctype-euc_kr.c:
  Fix for "unused argument" warning
strings/ctype-gb2312.c:
  Fix for "unused argument" warning
strings/ctype-gbk.c:
  Fix for "unused argument" warning
strings/ctype-latin1_de.c:
  Fix for "unused argument" warning
strings/ctype-simple.c:
  8bit<->unicode convertion routines
strings/ctype-sjis.c:
  Fix for "unused argument" warning
strings/ctype-tis620.c:
  Fix for "unused argument" warning
strings/ctype-ujis.c:
  Fix for "unused argument" warning
strings/ctype-utf8.c:
  Fix for "unused argument" warning
strings/ctype.c:
  8bit <-> unicode conversion tables
---
 mysys/hash.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index 3faaff1f169..d7d4cf83d55 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -114,7 +114,8 @@ static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
 
 	/* Calc hashvalue for a key */
 
-static uint calc_hashnr(CHARSET_INFO *cs, const byte *key,uint length)
+static uint calc_hashnr(CHARSET_INFO *cs __attribute__((unused)), 
+			const byte *key,uint length)
 {
   register uint nr=1, nr2=4;
   while (length--)
-- 
cgit v1.2.1


From 32ac1ef044428947f6396a47c275d06975133c8c Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Tue, 16 Apr 2002 18:21:53 +0500
Subject: Some fixes after merging changes from 4.0

include/hash.h:
  Monty forgot to add H in left part of macros
mysys/hash.c:
  I wonder how it happened that my_bool disappeared
sql/sql_acl.cc:
  Somebody forgot )
sql/sql_class.h:
  I wonder how it happened that this line disappeared
sql/sql_table.cc:
  small typo
sql/sql_yacc.yy:
  Having ; is more compatible
---
 mysys/hash.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index 656732598c1..a0c5c6e45f0 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -35,7 +35,7 @@ static uint calc_hashnr(CHARSET_INFO *cs,const byte *key,uint length);
 static uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key,uint length);
 static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
 
-
+my_bool
 _hash_init(HASH *hash,CHARSET_INFO *charset,
 		  uint size,uint key_offset,uint key_length,
 		  hash_get_key get_key,
-- 
cgit v1.2.1


From 804af496a1e5504fc0f5883b5dfb7502dcc0dbb4 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Wed, 17 Apr 2002 15:57:18 +0500
Subject: Some charsets require special hash function New file ctype-win1250ch,
 I forgot to commit it in my previous changes

include/m_ctype.h:
  Some charsets require special hash function
mysys/hash.c:
  Some charsets require special hash function
strings/ctype-utf8.c:
  Some charsets require special hash function
strings/ctype.c:
  Some charsets require special hash function
---
 mysys/hash.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index a0c5c6e45f0..770bd396d06 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -59,7 +59,12 @@ _hash_init(HASH *hash,CHARSET_INFO *charset,
   hash->flags=flags;
   hash->charset=charset;
   if (flags & HASH_CASE_INSENSITIVE)
-    hash->calc_hashnr=calc_hashnr_caseup;
+  {
+    if (charset->hash_caseup)
+      hash->calc_hashnr=charset->hash_caseup;
+    else
+      hash->calc_hashnr=calc_hashnr_caseup;
+  }
   else
     hash->calc_hashnr=calc_hashnr;
   DBUG_RETURN(0);
-- 
cgit v1.2.1


From 139a73cade4827ca2a41d6cfc9db379b2c696fa3 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Thu, 25 Apr 2002 13:36:55 +0500
Subject: RB-Tree indexes support in HEAP tables Renamed _hp_func  ->  hp_func
 mi_key_cmp moved to /mysys/my_handler.c New tests for HEAP tables

heap/_check.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/_rectest.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/heapdef.h:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_block.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_clear.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_close.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_create.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_delete.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_hash.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_open.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_panic.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rename.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rfirst.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rkey.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rlast.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rnext.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rprev.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rrnd.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_rsame.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_scan.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_test1.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_test2.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_update.c:
  RB-tree index
  Renamed _hp_func -> hp_func
heap/hp_write.c:
  RB-tree index
  Renamed _hp_func -> hp_func
include/Makefile.am:
  New include
include/heap.h:
  RB-Tree index
include/my_tree.h:
  new search functions
  new custom_arg argument
include/myisam.h:
  Removed MI_KEYSEG
isam/isamlog.c:
  Add custom_arg
isam/pack_isam.c:
  Add custom_arg
myisam/ft_nlq_search.c:
  Add custom_arg
myisam/ft_parser.c:
  Add custom_arg
myisam/ft_stopwords.c:
  Add custom_arg
myisam/mi_search.c:
  Remove mi_key_cmp
myisam/mi_write.c:
  Add custom_arg
myisam/myisamdef.h:
  Remove mi_key_cmp
myisam/myisamlog.c:
  Add custom_arg
myisam/myisampack.c:
  Add custom_arg
mysys/Makefile.am:
  New file my_handler.c
mysys/tree.c:
  custom_arg
  new search functions
sql/ha_heap.cc:
  RBTree
sql/ha_myisam.cc:
  RBTree
sql/item_sum.cc:
  custom_arg
sql/sql_analyse.cc:
  custom_arg
sql/sql_class.h:
  custom_arg
sql/sql_table.cc:
  Remove duplicate code
sql/sql_yacc.yy:
  UNDEF by default
sql/table.cc:
  Remove dirty hack
---
 mysys/Makefile.am  |   3 +-
 mysys/my_handler.c | 717 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 mysys/tree.c       | 189 +++++++++++++-
 3 files changed, 897 insertions(+), 12 deletions(-)
 create mode 100644 mysys/my_handler.c

(limited to 'mysys')

diff --git a/mysys/Makefile.am b/mysys/Makefile.am
index 287dc357b3d..a32740e2168 100644
--- a/mysys/Makefile.am
+++ b/mysys/Makefile.am
@@ -46,7 +46,8 @@ libmysys_a_SOURCES =	my_init.c my_getwd.c mf_getdate.c\
 			my_quick.c my_lockmem.c my_static.c \
 			getopt.c getopt1.c my_getopt.c getvar.c my_mkdir.c \
 			default.c my_compress.c checksum.c raid.cc my_net.c \
-			my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c
+			my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c \
+			my_handler.c
 EXTRA_DIST =		thr_alarm.c thr_lock.c my_pthread.c my_thr_init.c \
 			thr_mutex.c thr_rwlock.c
 libmysys_a_LIBADD =	@THREAD_LOBJECTS@
diff --git a/mysys/my_handler.c b/mysys/my_handler.c
new file mode 100644
index 00000000000..afaada615b4
--- /dev/null
+++ b/mysys/my_handler.c
@@ -0,0 +1,717 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library 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
+   Library General Public License for more details.
+   
+   You should have received a copy of the GNU Library General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA */
+
+#include "my_handler.h"
+
+int _mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
+                     uchar *b, uint b_length, my_bool part_key)
+{
+  int flag;
+
+#ifdef USE_STRCOLL
+  if (use_strcoll(charset_info))
+  {
+    /* QQ: This needs to work with part keys at some point */
+    return my_strnncoll(charset_info, a, a_length, b, b_length);
+  }
+  else
+#endif
+  {
+    uint length= min(a_length,b_length);
+    uchar *end= a+ length;
+    uchar *sort_order=charset_info->sort_order;
+    while (a < end)
+      if ((flag= (int) sort_order[*a++] - (int) sort_order[*b++]))
+        return flag;
+  }
+  if (part_key && b_length < a_length)
+    return 0;
+  return (int) (a_length-b_length);
+}
+
+static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
+                       my_bool part_key)
+{
+  uint length= min(a_length,b_length);
+  uchar *end= a+ length;
+  int flag;
+
+  while (a < end)
+    if ((flag= (int) *a++ - (int) *b++))
+      return flag;
+  if (part_key && b_length < a_length)
+    return 0;
+  return (int) (a_length-b_length);
+}
+
+#define CMP(a,b) (a<b ? -1 : a == b ? 0 : 1)
+#define FCMP(A,B) ((int) (A) - (int) (B))
+
+/*
+Compare two keys
+Returns <0, 0, >0 acording to which is bigger
+Key_length specifies length of key to use.  Number-keys can't be splited
+If flag <> SEARCH_FIND compare also position
+*/
+int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
+		register uchar *b, uint key_length, uint nextflag,
+		uint *diff_pos)
+{
+  int flag;
+  int16 s_1,s_2;
+  int32 l_1,l_2;
+  uint32 u_1,u_2;
+  float f_1,f_2;
+  double d_1,d_2;
+  uint next_key_length;
+
+  *diff_pos=0;
+  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
+  {
+    uchar *end;
+    (*diff_pos)++;
+
+    /* Handle NULL part */
+    if (keyseg->null_bit)
+    {
+      key_length--;
+      if (*a != *b)
+      {
+        flag = (int) *a - (int) *b;
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      }
+      b++;
+      if (!*a++)                                /* If key was NULL */
+      {
+        if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
+          nextflag=SEARCH_SAME;                 /* Allow duplicate keys */
+        next_key_length=key_length;
+        continue;                               /* To next key part */
+      }
+    }
+    end= a+ min(keyseg->length,key_length);
+    next_key_length=key_length-keyseg->length;
+
+    switch ((enum ha_base_keytype) keyseg->type) {
+    case HA_KEYTYPE_TEXT:                       /* Ascii; Key is converted */
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      else
+      {
+	uint length=(uint) (end-a), a_length=length, b_length=length;
+	if (!(nextflag & SEARCH_PREFIX))
+	{
+	  while (a_length && a[a_length-1] == ' ')
+	    a_length--;
+	  while (b_length && b[b_length-1] == ' ')
+	    b_length--;
+	}
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a=end;
+        b+=length;
+      }
+      break;
+    case HA_KEYTYPE_BINARY:
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=compare_bin(a,a_length,b,b_length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      else
+      {
+        uint length=keyseg->length;
+        if ((flag=compare_bin(a,length,b,length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=length;
+        b+=length;
+      }
+      break;
+    case HA_KEYTYPE_VARTEXT:
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      break;
+    case HA_KEYTYPE_VARBINARY:
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=compare_bin(a,a_length,b,b_length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      break;
+    case HA_KEYTYPE_INT8:
+    {
+      int i_1= (int) *((signed char*) a);
+      int i_2= (int) *((signed char*) b);
+      if ((flag = CMP(i_1,i_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a= end;
+      b++;
+      break;
+    }
+    case HA_KEYTYPE_SHORT_INT:
+      s_1= mi_sint2korr(a);
+      s_2= mi_sint2korr(b);
+      if ((flag = CMP(s_1,s_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 2; /* sizeof(short int); */
+      break;
+    case HA_KEYTYPE_USHORT_INT:
+      {
+        uint16 us_1,us_2;
+        us_1= mi_sint2korr(a);
+        us_2= mi_sint2korr(b);
+        if ((flag = CMP(us_1,us_2)))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a=  end;
+        b+=2; /* sizeof(short int); */
+        break;
+      }
+    case HA_KEYTYPE_LONG_INT:
+      l_1= mi_sint4korr(a);
+      l_2= mi_sint4korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(long int); */
+      break;
+    case HA_KEYTYPE_ULONG_INT:
+      u_1= mi_sint4korr(a);
+      u_2= mi_sint4korr(b);
+      if ((flag = CMP(u_1,u_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(long int); */
+      break;
+    case HA_KEYTYPE_INT24:
+      l_1=mi_sint3korr(a);
+      l_2=mi_sint3korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 3;
+      break;
+    case HA_KEYTYPE_UINT24:
+      l_1=mi_uint3korr(a);
+      l_2=mi_uint3korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 3;
+      break;
+    case HA_KEYTYPE_FLOAT:
+      mi_float4get(f_1,a);
+      mi_float4get(f_2,b);
+      if ((flag = CMP(f_1,f_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(float); */
+      break;
+    case HA_KEYTYPE_DOUBLE:
+      mi_float8get(d_1,a);
+      mi_float8get(d_2,b);
+      if ((flag = CMP(d_1,d_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;  /* sizeof(double); */
+      break;
+    case HA_KEYTYPE_NUM:                                /* Numeric key */
+    {
+      int swap_flag= 0;
+      int alength,blength;
+      
+      if (keyseg->flag & HA_REVERSE_SORT)
+      {
+        swap(uchar*,a,b);       
+        swap_flag=1;                            /* Remember swap of a & b */
+        end= a+ (int) (end-b);
+      }
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        alength= *a++; blength= *b++;
+        end=a+alength;
+        next_key_length=key_length-blength-1;
+      }
+      else
+      {
+        alength= (int) (end-a);
+        blength=keyseg->length;
+        /* remove pre space from keys */
+        for ( ; alength && *a == ' ' ; a++, alength--) ;
+        for ( ; blength && *b == ' ' ; b++, blength--) ;
+      }
+
+      if (*a == '-')
+      {
+        if (*b != '-')
+          return -1;
+        a++; b++;
+        swap(uchar*,a,b);
+        swap(int,alength,blength);
+        swap_flag=1-swap_flag;
+        alength--; blength--;
+        end=a+alength;
+      }
+      else if (*b == '-')
+        return 1;
+      while (alength && (*a == '+' || *a == '0'))
+      {
+        a++; alength--;
+      }
+      while (blength && (*b == '+' || *b == '0'))
+      {
+        b++; blength--;
+      }
+      if (alength != blength)
+        return (alength < blength) ? -1 : 1;
+      while (a < end)
+        if (*a++ !=  *b++)
+          return ((int) a[-1] - (int) b[-1]);
+
+      if (swap_flag)                            /* Restore pointers */
+        swap(uchar*,a,b);
+      break;
+    }
+#ifdef HAVE_LONG_LONG
+    case HA_KEYTYPE_LONGLONG:
+    {
+      longlong ll_a,ll_b;
+      ll_a= mi_sint8korr(a);
+      ll_b= mi_sint8korr(b);
+      if ((flag = CMP(ll_a,ll_b)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;
+      break;
+    }
+    case HA_KEYTYPE_ULONGLONG:
+    {
+      ulonglong ll_a,ll_b;
+      ll_a= mi_uint8korr(a);
+      ll_b= mi_uint8korr(b);
+      if ((flag = CMP(ll_a,ll_b)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;
+      break;
+    }
+#endif
+    case HA_KEYTYPE_END:                        /* Ready */
+      goto end;                                 /* diff_pos is incremented */
+    }
+  }
+  (*diff_pos)++;
+end:
+  if (!(nextflag & SEARCH_FIND))
+  {
+    uint i;
+    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
+      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
+    flag=0;
+    for (i=keyseg->length ; i-- > 0 ; )
+    {
+      if (*a++ != *b++)
+      {
+        flag= FCMP(a[-1],b[-1]);
+        break;
+      }
+    }
+    if (nextflag & SEARCH_SAME)
+      return (flag);                            /* read same */
+    if (nextflag & SEARCH_BIGGER)
+      return (flag <= 0 ? -1 : 1);              /* read next */
+    return (flag < 0 ? -1 : 1);                 /* read previous */
+  }
+  return 0;
+} /* my_key_cmp */
+
+/*
+Compare two keys
+Returns <0, 0, >0 acording to which is bigger
+Key_length specifies length of key to use.  Number-keys can't be splited
+If flag <> SEARCH_FIND compare also position
+*/
+int hp_rb_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
+		  register uchar *b, uint key_length, uint nextflag,
+		  uint *diff_pos)
+{
+  int flag;
+  int16 s_1,s_2;
+  int32 l_1,l_2;
+  uint32 u_1,u_2;
+  float f_1,f_2;
+  double d_1,d_2;
+  uint next_key_length;
+
+  *diff_pos=0;
+  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
+  {
+    uchar *end;
+    (*diff_pos)++;
+
+    /* Handle NULL part */
+    if (keyseg->null_bit)
+    {
+      key_length--;
+      if (*a != *b)
+      {
+        flag = (int) *a - (int) *b;
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      }
+      b++;
+      if (!*a++)                                /* If key was NULL */
+      {
+        if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
+          nextflag=SEARCH_SAME;                 /* Allow duplicate keys */
+        next_key_length=key_length;
+        a+= keyseg->length;
+        b+= keyseg->length;
+        key_length-= keyseg->length;
+        continue;                               /* To next key part */
+      }
+    }
+    end= a+ min(keyseg->length,key_length);
+    next_key_length=key_length-keyseg->length;
+
+    switch ((enum ha_base_keytype) keyseg->type) {
+    case HA_KEYTYPE_TEXT:                       /* Ascii; Key is converted */
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      else
+      {
+	uint length=(uint) (end-a), a_length=length, b_length=length;
+	if (!(nextflag & SEARCH_PREFIX))
+	{
+	  while (a_length && a[a_length-1] == ' ')
+	    a_length--;
+	  while (b_length && b[b_length-1] == ' ')
+	    b_length--;
+	}
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a=end;
+        b+=length;
+      }
+      break;
+    case HA_KEYTYPE_BINARY:
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=compare_bin(a,a_length,b,b_length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      else
+      {
+        uint length=keyseg->length;
+        if ((flag=compare_bin(a,length,b,length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=length;
+        b+=length;
+      }
+      break;
+    case HA_KEYTYPE_VARTEXT:
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                              next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      break;
+    case HA_KEYTYPE_VARBINARY:
+      {
+        int a_length,b_length,pack_length;
+        get_key_length(a_length,a);
+        get_key_pack_length(b_length,pack_length,b);
+        next_key_length=key_length-b_length-pack_length;
+
+        if ((flag=compare_bin(a,a_length,b,b_length,
+                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
+                                         next_key_length <= 0))))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a+=a_length;
+        b+=b_length;
+        break;
+      }
+      break;
+    case HA_KEYTYPE_INT8:
+    {
+      int i_1= (int) *((signed char*) a);
+      int i_2= (int) *((signed char*) b);
+      if ((flag = CMP(i_1,i_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a= end;
+      b++;
+      break;
+    }
+    case HA_KEYTYPE_SHORT_INT:
+      s_1= mi_sint2korr(a);
+      s_2= mi_sint2korr(b);
+      if ((flag = CMP(s_1,s_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 2; /* sizeof(short int); */
+      break;
+    case HA_KEYTYPE_USHORT_INT:
+      {
+        uint16 us_1,us_2;
+        us_1= mi_sint2korr(a);
+        us_2= mi_sint2korr(b);
+        if ((flag = CMP(us_1,us_2)))
+          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        a=  end;
+        b+=2; /* sizeof(short int); */
+        break;
+      }
+    case HA_KEYTYPE_LONG_INT:
+      l_1= mi_sint4korr(a);
+      l_2= mi_sint4korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(long int); */
+      break;
+    case HA_KEYTYPE_ULONG_INT:
+      u_1= mi_sint4korr(a);
+      u_2= mi_sint4korr(b);
+      if ((flag = CMP(u_1,u_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(long int); */
+      break;
+    case HA_KEYTYPE_INT24:
+      l_1=mi_sint3korr(a);
+      l_2=mi_sint3korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 3;
+      break;
+    case HA_KEYTYPE_UINT24:
+      l_1=mi_uint3korr(a);
+      l_2=mi_uint3korr(b);
+      if ((flag = CMP(l_1,l_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 3;
+      break;
+    case HA_KEYTYPE_FLOAT:
+      mi_float4get(f_1,a);
+      mi_float4get(f_2,b);
+      if ((flag = CMP(f_1,f_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 4; /* sizeof(float); */
+      break;
+    case HA_KEYTYPE_DOUBLE:
+      mi_float8get(d_1,a);
+      mi_float8get(d_2,b);
+      if ((flag = CMP(d_1,d_2)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;  /* sizeof(double); */
+      break;
+    case HA_KEYTYPE_NUM:                                /* Numeric key */
+    {
+      int swap_flag= 0;
+      int alength,blength;
+      
+      if (keyseg->flag & HA_REVERSE_SORT)
+      {
+        swap(uchar*,a,b);       
+        swap_flag=1;                            /* Remember swap of a & b */
+        end= a+ (int) (end-b);
+      }
+      if (keyseg->flag & HA_SPACE_PACK)
+      {
+        alength= *a++; blength= *b++;
+        end=a+alength;
+        next_key_length=key_length-blength-1;
+      }
+      else
+      {
+        alength= (int) (end-a);
+        blength=keyseg->length;
+        /* remove pre space from keys */
+        for ( ; alength && *a == ' ' ; a++, alength--) ;
+        for ( ; blength && *b == ' ' ; b++, blength--) ;
+      }
+
+      if (*a == '-')
+      {
+        if (*b != '-')
+          return -1;
+        a++; b++;
+        swap(uchar*,a,b);
+        swap(int,alength,blength);
+        swap_flag=1-swap_flag;
+        alength--; blength--;
+        end=a+alength;
+      }
+      else if (*b == '-')
+        return 1;
+      while (alength && (*a == '+' || *a == '0'))
+      {
+        a++; alength--;
+      }
+      while (blength && (*b == '+' || *b == '0'))
+      {
+        b++; blength--;
+      }
+      if (alength != blength)
+        return (alength < blength) ? -1 : 1;
+      while (a < end)
+        if (*a++ !=  *b++)
+          return ((int) a[-1] - (int) b[-1]);
+
+      if (swap_flag)                            /* Restore pointers */
+        swap(uchar*,a,b);
+      break;
+    }
+#ifdef HAVE_LONG_LONG
+    case HA_KEYTYPE_LONGLONG:
+    {
+      longlong ll_a,ll_b;
+      ll_a= mi_sint8korr(a);
+      ll_b= mi_sint8korr(b);
+      if ((flag = CMP(ll_a,ll_b)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;
+      break;
+    }
+    case HA_KEYTYPE_ULONGLONG:
+    {
+      ulonglong ll_a,ll_b;
+      ll_a= mi_uint8korr(a);
+      ll_b= mi_uint8korr(b);
+      if ((flag = CMP(ll_a,ll_b)))
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+      a=  end;
+      b+= 8;
+      break;
+    }
+#endif
+    case HA_KEYTYPE_END:                        /* Ready */
+      goto end;                                 /* diff_pos is incremented */
+    }
+  }
+  (*diff_pos)++;
+end:
+  if (!(nextflag & SEARCH_FIND))
+  {
+    uint i;
+    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
+      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
+    flag=0;
+    for (i=keyseg->length ; i-- > 0 ; )
+    {
+      if (*a++ != *b++)
+      {
+        flag= FCMP(a[-1],b[-1]);
+        break;
+      }
+    }
+    if (nextflag & SEARCH_SAME)
+      return (flag);                            /* read same */
+    if (nextflag & SEARCH_BIGGER)
+      return (flag <= 0 ? -1 : 1);              /* read next */
+    return (flag < 0 ? -1 : 1);                 /* read previous */
+  }
+  return 0;
+} /* my_key_cmp */
diff --git a/mysys/tree.c b/mysys/tree.c
index 2ac2c88fd66..632660344b5 100644
--- a/mysys/tree.c
+++ b/mysys/tree.c
@@ -42,6 +42,7 @@
 #include "mysys_priv.h"
 #include <m_string.h>
 #include <my_tree.h>
+#include "my_base.h"
 
 #define BLACK		1
 #define RED		0
@@ -167,7 +168,8 @@ static void delete_tree_element(TREE *tree, TREE_ELEMENT *element)
 	     parent[0] = & parent[-1][0]->right */
 
 
-TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size)
+TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size, 
+                          void* custom_arg)
 {
   int cmp;
   TREE_ELEMENT *element,***parent;
@@ -177,8 +179,8 @@ TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size)
   for (;;)
   {
     if (element == &tree->null_element ||
-	(cmp=(*tree->compare)(tree->custom_arg,
-			      ELEMENT_KEY(tree,element),key)) == 0)
+	(cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
+                                key)) == 0)
       break;
     if (cmp < 0)
     {
@@ -198,7 +200,7 @@ TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size)
                            && tree->allocated > tree->memory_limit)
     {
       reset_tree(tree);
-      return tree_insert(tree, key, key_size);
+      return tree_insert(tree, key, key_size, custom_arg);
     }
 
     key_size+=tree->size_of_element;
@@ -234,8 +236,7 @@ TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size)
   return element;
 }
 
-
-int tree_delete(TREE *tree, void *key)
+int tree_delete(TREE *tree, void *key, void *custom_arg)
 {
   int cmp,remove_colour;
   TREE_ELEMENT *element,***parent, ***org_parent, *nod;
@@ -248,8 +249,8 @@ int tree_delete(TREE *tree, void *key)
   {
     if (element == &tree->null_element)
       return 1;				/* Was not in tree */
-    if ((cmp=(*tree->compare)(tree->custom_arg,
-			      ELEMENT_KEY(tree,element),key)) == 0)
+    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
+                                key)) == 0)
       break;
     if (cmp < 0)
     {
@@ -296,7 +297,7 @@ int tree_delete(TREE *tree, void *key)
 }
 
 
-void *tree_search(TREE *tree, void *key)
+void *tree_search(TREE *tree, void *key, void *custom_arg)
 {
   int cmp;
   TREE_ELEMENT *element=tree->root;
@@ -305,8 +306,8 @@ void *tree_search(TREE *tree, void *key)
   {
     if (element == &tree->null_element)
       return (void*) 0;
-    if ((cmp=(*tree->compare)(tree->custom_arg,
-			      ELEMENT_KEY(tree,element),key)) == 0)
+    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
+                                key)) == 0)
       return ELEMENT_KEY(tree,element);
     if (cmp < 0)
       element=element->right;
@@ -315,6 +316,172 @@ void *tree_search(TREE *tree, void *key)
   }
 }
 
+void *tree_search_key(TREE *tree, const void *key, 
+                      TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
+                      enum ha_rkey_function flag, void *custom_arg)
+{
+  int cmp;
+  TREE_ELEMENT *element = tree->root;
+  TREE_ELEMENT **last_left_step_parent = NULL;
+  TREE_ELEMENT **last_equal_element = NULL;
+
+/* 
+  TODO: handle HA_READ_KEY_OR_PREV, HA_READ_BEFORE_KEY, HA_READ_PREFIX, 
+  HA_READ_PREFIX_LAST flags if needed.
+*/
+
+  *parents = &tree->null_element;
+  while (element != &tree->null_element)
+  {
+    *++parents = element;
+    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
+                                key)) == 0)
+    {
+      switch (flag) {
+      case HA_READ_KEY_EXACT:
+      case HA_READ_KEY_OR_NEXT:
+        last_equal_element = parents;
+        cmp = 1;
+        break;
+      case HA_READ_AFTER_KEY:
+        cmp = -1;
+        break;
+      default:
+        return NULL;
+      }
+    }
+    if (cmp < 0) /* element < key */
+    {
+      element = element->right;
+    }
+    else
+    {
+      last_left_step_parent = parents;
+      element = element->left;
+    }
+  }
+  switch (flag) {
+  case HA_READ_KEY_EXACT:
+    *last_pos = last_equal_element;
+    break;
+  case HA_READ_KEY_OR_NEXT:
+    *last_pos = last_equal_element ? last_equal_element : last_left_step_parent;
+    break;
+  case HA_READ_AFTER_KEY:
+    *last_pos = last_left_step_parent;
+    break;
+  default:
+    return NULL;
+  }
+  return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
+}
+
+/* 
+  Search first (the most left) or last (the most right) tree element 
+*/
+void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents, 
+                        TREE_ELEMENT ***last_pos, int child_offs)
+{
+  TREE_ELEMENT *element = tree->root;
+  
+  *parents = &tree->null_element;
+  while (element != &tree->null_element)
+  {
+    *++parents = element;
+    element = ELEMENT_CHILD(element, child_offs);
+  }
+  *last_pos = parents;
+  return **last_pos != &tree->null_element ? 
+    ELEMENT_KEY(tree, **last_pos) : NULL;
+}
+
+void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs, 
+                       int r_offs)
+{
+  TREE_ELEMENT *x = **last_pos;
+  
+  if (ELEMENT_CHILD(x, r_offs) != &tree->null_element)
+  {
+    x = ELEMENT_CHILD(x, r_offs);
+    *++*last_pos = x;
+    while (ELEMENT_CHILD(x, l_offs) != &tree->null_element)
+    {
+      x = ELEMENT_CHILD(x, l_offs);
+      *++*last_pos = x;
+    }
+    return ELEMENT_KEY(tree, x);
+  }
+  else
+  {
+    TREE_ELEMENT *y = *--*last_pos;
+    while (y != &tree->null_element && x == ELEMENT_CHILD(y, r_offs))
+    {
+      x = y;
+      y = *--*last_pos;
+    }
+    return y == &tree->null_element ? NULL : ELEMENT_KEY(tree, y);
+  }
+}
+
+/*
+  Expected that tree is fully balanced
+  (each path from root to leaf has the same length)
+*/
+uint tree_record_pos(TREE *tree, const void *key, 
+                     enum ha_rkey_function flag, void *custom_arg)
+{
+  int cmp;
+  TREE_ELEMENT *element = tree->root;
+  uint left = 1;
+  uint right = tree->elements_in_tree;
+  uint last_left_step_pos = tree->elements_in_tree;
+  uint last_right_step_pos = 1;
+  uint last_equal_pos = HA_POS_ERROR;
+
+  while (element != &tree->null_element)
+  {
+    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
+                                key)) == 0)
+    {
+      switch (flag) {
+      case HA_READ_KEY_EXACT:
+        last_equal_pos = (left + right) >> 1;
+        cmp = 1;
+        break;
+      case HA_READ_BEFORE_KEY:
+        cmp = 1;
+        break;
+      case HA_READ_AFTER_KEY:
+        cmp = -1;
+        break;
+      default:
+        return HA_POS_ERROR;
+      }
+    }
+    if (cmp < 0) /* element < key */
+    {
+      last_right_step_pos = (left + right) >> 1;
+      element = element->right;
+      left = last_right_step_pos;
+    }
+    else
+    {
+      last_left_step_pos = (left + right) >> 1;
+      element = element->left;
+      right = last_left_step_pos;
+    }
+  }
+  switch (flag) {
+  case HA_READ_KEY_EXACT:
+    return last_equal_pos;
+  case HA_READ_BEFORE_KEY:
+    return last_right_step_pos;
+  case HA_READ_AFTER_KEY:
+    return last_left_step_pos;
+  default:
+    return HA_POS_ERROR;
+  }
+}
 
 int tree_walk(TREE *tree, tree_walk_action action, void *argument, TREE_WALK visit)
 {
-- 
cgit v1.2.1


From 3adee5046d70aa91fead16c289dd2a1b098b3dfd Mon Sep 17 00:00:00 2001
From: unknown <ram@gw.udmsearch.izhnet.ru>
Date: Thu, 25 Apr 2002 15:10:29 +0500
Subject: MI_KEYSEG   -> HA_KEYSEG _mi_key_cmp -> ha_key_cmp

BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted
---
 mysys/my_handler.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'mysys')

diff --git a/mysys/my_handler.c b/mysys/my_handler.c
index afaada615b4..5544c7cc483 100644
--- a/mysys/my_handler.c
+++ b/mysys/my_handler.c
@@ -67,7 +67,7 @@ Returns <0, 0, >0 acording to which is bigger
 Key_length specifies length of key to use.  Number-keys can't be splited
 If flag <> SEARCH_FIND compare also position
 */
-int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
+int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 		register uchar *b, uint key_length, uint nextflag,
 		uint *diff_pos)
 {
@@ -393,7 +393,7 @@ Returns <0, 0, >0 acording to which is bigger
 Key_length specifies length of key to use.  Number-keys can't be splited
 If flag <> SEARCH_FIND compare also position
 */
-int hp_rb_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
+int hp_rb_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 		  register uchar *b, uint key_length, uint nextflag,
 		  uint *diff_pos)
 {
-- 
cgit v1.2.1


From c811538f89925b7111e4ee0e3b940726f32a64d9 Mon Sep 17 00:00:00 2001
From: unknown <ram@gw.udmsearch.izhnet.ru>
Date: Tue, 21 May 2002 21:54:08 +0500
Subject: BTREE heap key structure is now the same as MyISAM _mi_compare_text
 -> mi_compate_text Changes according Monty's suggestions

heap/heapdef.h:
  BTREE heap key structure is now the same as MyISAM
heap/hp_delete.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_hash.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_open.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_rfirst.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_rkey.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_rlast.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_rnext.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_rprev.c:
  BTREE heap key structure is now the same as MyISAM
heap/hp_write.c:
  BTREE heap key structure is now the same as MyISAM
include/heap.h:
  BTREE heap key structure is now the same as MyISAM
include/my_handler.h:
  Removed hp_rb_key_cmp()
  _mi_compare_text -> mi_compate_text
include/my_tree.h:
  Fixed typo
myisam/ft_boolean_search.c:
  _mi_compare_text -> mi_compate_text
myisam/ft_nlq_search.c:
  _mi_compare_text -> mi_compate_text
myisam/ft_parser.c:
  _mi_compare_text -> mi_compate_text
myisam/ft_stopwords.c:
  _mi_compare_text -> mi_compate_text
myisam/ft_update.c:
  _mi_compare_text -> mi_compate_text
mysys/my_handler.c:
  Removed hp_rb_key_cmp()
  _mi_compare_text -> mi_compate_text
mysys/tree.c:
  BTREE heap key structure is now the same as MyISAM
sql/ha_heap.cc:
  BTREE heap key structure is now the same as MyISAM
---
 mysys/my_handler.c | 341 +----------------------------------------------------
 mysys/tree.c       |  64 +++++-----
 2 files changed, 36 insertions(+), 369 deletions(-)

(limited to 'mysys')

diff --git a/mysys/my_handler.c b/mysys/my_handler.c
index 5544c7cc483..7d73dbb1531 100644
--- a/mysys/my_handler.c
+++ b/mysys/my_handler.c
@@ -17,8 +17,8 @@
 
 #include "my_handler.h"
 
-int _mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
-                     uchar *b, uint b_length, my_bool part_key)
+int mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
+		    uchar *b, uint b_length, my_bool part_key)
 {
   int flag;
 
@@ -115,7 +115,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -133,7 +133,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 	  while (b_length && b[b_length-1] == ' ')
 	    b_length--;
 	}
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -175,7 +175,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -385,333 +385,4 @@ end:
     return (flag < 0 ? -1 : 1);                 /* read previous */
   }
   return 0;
-} /* my_key_cmp */
-
-/*
-Compare two keys
-Returns <0, 0, >0 acording to which is bigger
-Key_length specifies length of key to use.  Number-keys can't be splited
-If flag <> SEARCH_FIND compare also position
-*/
-int hp_rb_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
-		  register uchar *b, uint key_length, uint nextflag,
-		  uint *diff_pos)
-{
-  int flag;
-  int16 s_1,s_2;
-  int32 l_1,l_2;
-  uint32 u_1,u_2;
-  float f_1,f_2;
-  double d_1,d_2;
-  uint next_key_length;
-
-  *diff_pos=0;
-  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
-  {
-    uchar *end;
-    (*diff_pos)++;
-
-    /* Handle NULL part */
-    if (keyseg->null_bit)
-    {
-      key_length--;
-      if (*a != *b)
-      {
-        flag = (int) *a - (int) *b;
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      }
-      b++;
-      if (!*a++)                                /* If key was NULL */
-      {
-        if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
-          nextflag=SEARCH_SAME;                 /* Allow duplicate keys */
-        next_key_length=key_length;
-        a+= keyseg->length;
-        b+= keyseg->length;
-        key_length-= keyseg->length;
-        continue;                               /* To next key part */
-      }
-    }
-    end= a+ min(keyseg->length,key_length);
-    next_key_length=key_length-keyseg->length;
-
-    switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:                       /* Ascii; Key is converted */
-      if (keyseg->flag & HA_SPACE_PACK)
-      {
-        int a_length,b_length,pack_length;
-        get_key_length(a_length,a);
-        get_key_pack_length(b_length,pack_length,b);
-        next_key_length=key_length-b_length-pack_length;
-
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
-                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                              next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a+=a_length;
-        b+=b_length;
-        break;
-      }
-      else
-      {
-	uint length=(uint) (end-a), a_length=length, b_length=length;
-	if (!(nextflag & SEARCH_PREFIX))
-	{
-	  while (a_length && a[a_length-1] == ' ')
-	    a_length--;
-	  while (b_length && b[b_length-1] == ' ')
-	    b_length--;
-	}
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
-                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                              next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a=end;
-        b+=length;
-      }
-      break;
-    case HA_KEYTYPE_BINARY:
-      if (keyseg->flag & HA_SPACE_PACK)
-      {
-        int a_length,b_length,pack_length;
-        get_key_length(a_length,a);
-        get_key_pack_length(b_length,pack_length,b);
-        next_key_length=key_length-b_length-pack_length;
-
-        if ((flag=compare_bin(a,a_length,b,b_length,
-                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                         next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a+=a_length;
-        b+=b_length;
-        break;
-      }
-      else
-      {
-        uint length=keyseg->length;
-        if ((flag=compare_bin(a,length,b,length,
-                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                         next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a+=length;
-        b+=length;
-      }
-      break;
-    case HA_KEYTYPE_VARTEXT:
-      {
-        int a_length,b_length,pack_length;
-        get_key_length(a_length,a);
-        get_key_pack_length(b_length,pack_length,b);
-        next_key_length=key_length-b_length-pack_length;
-
-        if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
-                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                              next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a+=a_length;
-        b+=b_length;
-        break;
-      }
-      break;
-    case HA_KEYTYPE_VARBINARY:
-      {
-        int a_length,b_length,pack_length;
-        get_key_length(a_length,a);
-        get_key_pack_length(b_length,pack_length,b);
-        next_key_length=key_length-b_length-pack_length;
-
-        if ((flag=compare_bin(a,a_length,b,b_length,
-                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
-                                         next_key_length <= 0))))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a+=a_length;
-        b+=b_length;
-        break;
-      }
-      break;
-    case HA_KEYTYPE_INT8:
-    {
-      int i_1= (int) *((signed char*) a);
-      int i_2= (int) *((signed char*) b);
-      if ((flag = CMP(i_1,i_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a= end;
-      b++;
-      break;
-    }
-    case HA_KEYTYPE_SHORT_INT:
-      s_1= mi_sint2korr(a);
-      s_2= mi_sint2korr(b);
-      if ((flag = CMP(s_1,s_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 2; /* sizeof(short int); */
-      break;
-    case HA_KEYTYPE_USHORT_INT:
-      {
-        uint16 us_1,us_2;
-        us_1= mi_sint2korr(a);
-        us_2= mi_sint2korr(b);
-        if ((flag = CMP(us_1,us_2)))
-          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-        a=  end;
-        b+=2; /* sizeof(short int); */
-        break;
-      }
-    case HA_KEYTYPE_LONG_INT:
-      l_1= mi_sint4korr(a);
-      l_2= mi_sint4korr(b);
-      if ((flag = CMP(l_1,l_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 4; /* sizeof(long int); */
-      break;
-    case HA_KEYTYPE_ULONG_INT:
-      u_1= mi_sint4korr(a);
-      u_2= mi_sint4korr(b);
-      if ((flag = CMP(u_1,u_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 4; /* sizeof(long int); */
-      break;
-    case HA_KEYTYPE_INT24:
-      l_1=mi_sint3korr(a);
-      l_2=mi_sint3korr(b);
-      if ((flag = CMP(l_1,l_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 3;
-      break;
-    case HA_KEYTYPE_UINT24:
-      l_1=mi_uint3korr(a);
-      l_2=mi_uint3korr(b);
-      if ((flag = CMP(l_1,l_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 3;
-      break;
-    case HA_KEYTYPE_FLOAT:
-      mi_float4get(f_1,a);
-      mi_float4get(f_2,b);
-      if ((flag = CMP(f_1,f_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 4; /* sizeof(float); */
-      break;
-    case HA_KEYTYPE_DOUBLE:
-      mi_float8get(d_1,a);
-      mi_float8get(d_2,b);
-      if ((flag = CMP(d_1,d_2)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 8;  /* sizeof(double); */
-      break;
-    case HA_KEYTYPE_NUM:                                /* Numeric key */
-    {
-      int swap_flag= 0;
-      int alength,blength;
-      
-      if (keyseg->flag & HA_REVERSE_SORT)
-      {
-        swap(uchar*,a,b);       
-        swap_flag=1;                            /* Remember swap of a & b */
-        end= a+ (int) (end-b);
-      }
-      if (keyseg->flag & HA_SPACE_PACK)
-      {
-        alength= *a++; blength= *b++;
-        end=a+alength;
-        next_key_length=key_length-blength-1;
-      }
-      else
-      {
-        alength= (int) (end-a);
-        blength=keyseg->length;
-        /* remove pre space from keys */
-        for ( ; alength && *a == ' ' ; a++, alength--) ;
-        for ( ; blength && *b == ' ' ; b++, blength--) ;
-      }
-
-      if (*a == '-')
-      {
-        if (*b != '-')
-          return -1;
-        a++; b++;
-        swap(uchar*,a,b);
-        swap(int,alength,blength);
-        swap_flag=1-swap_flag;
-        alength--; blength--;
-        end=a+alength;
-      }
-      else if (*b == '-')
-        return 1;
-      while (alength && (*a == '+' || *a == '0'))
-      {
-        a++; alength--;
-      }
-      while (blength && (*b == '+' || *b == '0'))
-      {
-        b++; blength--;
-      }
-      if (alength != blength)
-        return (alength < blength) ? -1 : 1;
-      while (a < end)
-        if (*a++ !=  *b++)
-          return ((int) a[-1] - (int) b[-1]);
-
-      if (swap_flag)                            /* Restore pointers */
-        swap(uchar*,a,b);
-      break;
-    }
-#ifdef HAVE_LONG_LONG
-    case HA_KEYTYPE_LONGLONG:
-    {
-      longlong ll_a,ll_b;
-      ll_a= mi_sint8korr(a);
-      ll_b= mi_sint8korr(b);
-      if ((flag = CMP(ll_a,ll_b)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 8;
-      break;
-    }
-    case HA_KEYTYPE_ULONGLONG:
-    {
-      ulonglong ll_a,ll_b;
-      ll_a= mi_uint8korr(a);
-      ll_b= mi_uint8korr(b);
-      if ((flag = CMP(ll_a,ll_b)))
-        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-      a=  end;
-      b+= 8;
-      break;
-    }
-#endif
-    case HA_KEYTYPE_END:                        /* Ready */
-      goto end;                                 /* diff_pos is incremented */
-    }
-  }
-  (*diff_pos)++;
-end:
-  if (!(nextflag & SEARCH_FIND))
-  {
-    uint i;
-    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
-      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
-    flag=0;
-    for (i=keyseg->length ; i-- > 0 ; )
-    {
-      if (*a++ != *b++)
-      {
-        flag= FCMP(a[-1],b[-1]);
-        break;
-      }
-    }
-    if (nextflag & SEARCH_SAME)
-      return (flag);                            /* read same */
-    if (nextflag & SEARCH_BIGGER)
-      return (flag <= 0 ? -1 : 1);              /* read next */
-    return (flag < 0 ? -1 : 1);                 /* read previous */
-  }
-  return 0;
-} /* my_key_cmp */
+} /* ha_key_cmp */
diff --git a/mysys/tree.c b/mysys/tree.c
index 632660344b5..1bd49ef5182 100644
--- a/mysys/tree.c
+++ b/mysys/tree.c
@@ -380,17 +380,17 @@ void *tree_search_key(TREE *tree, const void *key,
   Search first (the most left) or last (the most right) tree element 
 */
 void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents, 
-                        TREE_ELEMENT ***last_pos, int child_offs)
+		       TREE_ELEMENT ***last_pos, int child_offs)
 {
-  TREE_ELEMENT *element = tree->root;
+  TREE_ELEMENT *element= tree->root;
   
-  *parents = &tree->null_element;
+  *parents= &tree->null_element;
   while (element != &tree->null_element)
   {
-    *++parents = element;
-    element = ELEMENT_CHILD(element, child_offs);
+    *++parents= element;
+    element= ELEMENT_CHILD(element, child_offs);
   }
-  *last_pos = parents;
+  *last_pos= parents;
   return **last_pos != &tree->null_element ? 
     ELEMENT_KEY(tree, **last_pos) : NULL;
 }
@@ -398,26 +398,26 @@ void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents,
 void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs, 
                        int r_offs)
 {
-  TREE_ELEMENT *x = **last_pos;
+  TREE_ELEMENT *x= **last_pos;
   
   if (ELEMENT_CHILD(x, r_offs) != &tree->null_element)
   {
-    x = ELEMENT_CHILD(x, r_offs);
-    *++*last_pos = x;
+    x= ELEMENT_CHILD(x, r_offs);
+    *++*last_pos= x;
     while (ELEMENT_CHILD(x, l_offs) != &tree->null_element)
     {
-      x = ELEMENT_CHILD(x, l_offs);
-      *++*last_pos = x;
+      x= ELEMENT_CHILD(x, l_offs);
+      *++*last_pos= x;
     }
     return ELEMENT_KEY(tree, x);
   }
   else
   {
-    TREE_ELEMENT *y = *--*last_pos;
+    TREE_ELEMENT *y= *--*last_pos;
     while (y != &tree->null_element && x == ELEMENT_CHILD(y, r_offs))
     {
-      x = y;
-      y = *--*last_pos;
+      x= y;
+      y= *--*last_pos;
     }
     return y == &tree->null_element ? NULL : ELEMENT_KEY(tree, y);
   }
@@ -431,28 +431,26 @@ uint tree_record_pos(TREE *tree, const void *key,
                      enum ha_rkey_function flag, void *custom_arg)
 {
   int cmp;
-  TREE_ELEMENT *element = tree->root;
-  uint left = 1;
-  uint right = tree->elements_in_tree;
-  uint last_left_step_pos = tree->elements_in_tree;
-  uint last_right_step_pos = 1;
-  uint last_equal_pos = HA_POS_ERROR;
+  TREE_ELEMENT *element= tree->root;
+  double left= 1;
+  double right= tree->elements_in_tree;
+  uint last_equal_pos= HA_POS_ERROR;
 
   while (element != &tree->null_element)
   {
-    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
-                                key)) == 0)
+    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
+			       key)) == 0)
     {
       switch (flag) {
       case HA_READ_KEY_EXACT:
-        last_equal_pos = (left + right) >> 1;
-        cmp = 1;
+        last_equal_pos= (left + right) / 2;
+        cmp= 1;
         break;
       case HA_READ_BEFORE_KEY:
-        cmp = 1;
+        cmp= 1;
         break;
       case HA_READ_AFTER_KEY:
-        cmp = -1;
+        cmp= -1;
         break;
       default:
         return HA_POS_ERROR;
@@ -460,24 +458,22 @@ uint tree_record_pos(TREE *tree, const void *key,
     }
     if (cmp < 0) /* element < key */
     {
-      last_right_step_pos = (left + right) >> 1;
-      element = element->right;
-      left = last_right_step_pos;
+      element= element->right;
+      left= (left + right) / 2;
     }
     else
     {
-      last_left_step_pos = (left + right) >> 1;
-      element = element->left;
-      right = last_left_step_pos;
+      element= element->left;
+      right= (left + right) / 2;
     }
   }
   switch (flag) {
   case HA_READ_KEY_EXACT:
     return last_equal_pos;
   case HA_READ_BEFORE_KEY:
-    return last_right_step_pos;
+    return (uint) right;
   case HA_READ_AFTER_KEY:
-    return last_left_step_pos;
+    return (uint) left;
   default:
     return HA_POS_ERROR;
   }
-- 
cgit v1.2.1


From a8652e9957e014c19b47635e09147a7bc17a3b8c Mon Sep 17 00:00:00 2001
From: unknown <monty@hundin.mysql.fi>
Date: Wed, 22 May 2002 18:51:21 +0300
Subject:  Fixed problem in fulltest testcase

include/my_base.h:
  Fix to ensure that old tables works in 4.1
myisam/mi_open.c:
  cleanup
mysys/my_handler.c:
  Fixed problem in fulltest testcase
sql/spatial.cc:
  cleanup
sql/sql_table.cc:
  cleanup
---
 mysys/my_handler.c | 109 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 62 insertions(+), 47 deletions(-)

(limited to 'mysys')

diff --git a/mysys/my_handler.c b/mysys/my_handler.c
index 7d73dbb1531..1e7d8a702d2 100644
--- a/mysys/my_handler.c
+++ b/mysys/my_handler.c
@@ -58,18 +58,18 @@ static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
   return (int) (a_length-b_length);
 }
 
-#define CMP(a,b) (a<b ? -1 : a == b ? 0 : 1)
 #define FCMP(A,B) ((int) (A) - (int) (B))
 
 /*
-Compare two keys
-Returns <0, 0, >0 acording to which is bigger
-Key_length specifies length of key to use.  Number-keys can't be splited
-If flag <> SEARCH_FIND compare also position
+  Compare two keys
+  Returns <0, 0, >0 acording to which is bigger
+  Key_length specifies length of key to use.  Number-keys can't be splited
+  If flag <> SEARCH_FIND compare also position
 */
+
 int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
-		register uchar *b, uint key_length, uint nextflag,
-		uint *diff_pos)
+	       register uchar *b, uint key_length, uint nextflag,
+	       uint *diff_pos)
 {
   int flag;
   int16 s_1,s_2;
@@ -83,13 +83,14 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
   for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
   {
     uchar *end;
+    uint piks=! (keyseg->flag & HA_NO_SORT);
     (*diff_pos)++;
 
     /* Handle NULL part */
     if (keyseg->null_bit)
     {
       key_length--;
-      if (*a != *b)
+      if (*a != *b && piks)
       {
         flag = (int) *a - (int) *b;
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -115,7 +116,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if (piks &&
+	    (flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -133,7 +135,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 	  while (b_length && b[b_length-1] == ' ')
 	    b_length--;
 	}
-        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if (piks &&
+	    (flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -149,7 +152,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag=compare_bin(a,a_length,b,b_length,
+        if (piks &&
+	    (flag=compare_bin(a,a_length,b,b_length,
                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                          next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -160,7 +164,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
       else
       {
         uint length=keyseg->length;
-        if ((flag=compare_bin(a,length,b,length,
+        if (piks &&
+	    (flag=compare_bin(a,length,b,length,
                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                          next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -175,7 +180,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
+        if (piks &&
+	    (flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                               next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -191,7 +197,8 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         get_key_pack_length(b_length,pack_length,b);
         next_key_length=key_length-b_length-pack_length;
 
-        if ((flag=compare_bin(a,a_length,b,b_length,
+        if (piks &&
+	    (flag=compare_bin(a,a_length,b,b_length,
                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
                                          next_key_length <= 0))))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
@@ -204,7 +211,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     {
       int i_1= (int) *((signed char*) a);
       int i_2= (int) *((signed char*) b);
-      if ((flag = CMP(i_1,i_2)))
+      if (piks && (flag = CMP_NUM(i_1,i_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a= end;
       b++;
@@ -213,7 +220,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_SHORT_INT:
       s_1= mi_sint2korr(a);
       s_2= mi_sint2korr(b);
-      if ((flag = CMP(s_1,s_2)))
+      if (piks && (flag = CMP_NUM(s_1,s_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 2; /* sizeof(short int); */
@@ -223,7 +230,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         uint16 us_1,us_2;
         us_1= mi_sint2korr(a);
         us_2= mi_sint2korr(b);
-        if ((flag = CMP(us_1,us_2)))
+        if (piks && (flag = CMP_NUM(us_1,us_2)))
           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
         a=  end;
         b+=2; /* sizeof(short int); */
@@ -232,7 +239,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_LONG_INT:
       l_1= mi_sint4korr(a);
       l_2= mi_sint4korr(b);
-      if ((flag = CMP(l_1,l_2)))
+      if (piks && (flag = CMP_NUM(l_1,l_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(long int); */
@@ -240,7 +247,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_ULONG_INT:
       u_1= mi_sint4korr(a);
       u_2= mi_sint4korr(b);
-      if ((flag = CMP(u_1,u_2)))
+      if (piks && (flag = CMP_NUM(u_1,u_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(long int); */
@@ -248,7 +255,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_INT24:
       l_1=mi_sint3korr(a);
       l_2=mi_sint3korr(b);
-      if ((flag = CMP(l_1,l_2)))
+      if (piks && (flag = CMP_NUM(l_1,l_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 3;
@@ -256,7 +263,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_UINT24:
       l_1=mi_uint3korr(a);
       l_2=mi_uint3korr(b);
-      if ((flag = CMP(l_1,l_2)))
+      if (piks && (flag = CMP_NUM(l_1,l_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 3;
@@ -264,7 +271,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_FLOAT:
       mi_float4get(f_1,a);
       mi_float4get(f_2,b);
-      if ((flag = CMP(f_1,f_2)))
+      if (piks && (flag = CMP_NUM(f_1,f_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(float); */
@@ -272,7 +279,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
     case HA_KEYTYPE_DOUBLE:
       mi_float8get(d_1,a);
       mi_float8get(d_2,b);
-      if ((flag = CMP(d_1,d_2)))
+      if (piks && (flag = CMP_NUM(d_1,d_2)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 8;  /* sizeof(double); */
@@ -303,32 +310,40 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
         for ( ; blength && *b == ' ' ; b++, blength--) ;
       }
 
-      if (*a == '-')
+      if (piks)
       {
-        if (*b != '-')
-          return -1;
-        a++; b++;
-        swap(uchar*,a,b);
-        swap(int,alength,blength);
-        swap_flag=1-swap_flag;
-        alength--; blength--;
-        end=a+alength;
-      }
-      else if (*b == '-')
-        return 1;
-      while (alength && (*a == '+' || *a == '0'))
-      {
-        a++; alength--;
+	if (*a == '-')
+	{
+	  if (*b != '-')
+	    return -1;
+	  a++; b++;
+	  swap(uchar*,a,b);
+	  swap(int,alength,blength);
+	  swap_flag=1-swap_flag;
+	  alength--; blength--;
+	  end=a+alength;
+	}
+	else if (*b == '-')
+	  return 1;
+	while (alength && (*a == '+' || *a == '0'))
+	{
+	  a++; alength--;
+	}
+	while (blength && (*b == '+' || *b == '0'))
+	{
+	  b++; blength--;
+	}
+	if (alength != blength)
+	  return (alength < blength) ? -1 : 1;
+	while (a < end)
+	  if (*a++ !=  *b++)
+	    return ((int) a[-1] - (int) b[-1]);
       }
-      while (blength && (*b == '+' || *b == '0'))
+      else
       {
-        b++; blength--;
+        b+=(end-a);
+        a=end;
       }
-      if (alength != blength)
-        return (alength < blength) ? -1 : 1;
-      while (a < end)
-        if (*a++ !=  *b++)
-          return ((int) a[-1] - (int) b[-1]);
 
       if (swap_flag)                            /* Restore pointers */
         swap(uchar*,a,b);
@@ -340,7 +355,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
       longlong ll_a,ll_b;
       ll_a= mi_sint8korr(a);
       ll_b= mi_sint8korr(b);
-      if ((flag = CMP(ll_a,ll_b)))
+      if (piks && (flag = CMP_NUM(ll_a,ll_b)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 8;
@@ -351,7 +366,7 @@ int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
       ulonglong ll_a,ll_b;
       ll_a= mi_uint8korr(a);
       ll_b= mi_uint8korr(b);
-      if ((flag = CMP(ll_a,ll_b)))
+      if (piks && (flag = CMP_NUM(ll_a,ll_b)))
         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 8;
-- 
cgit v1.2.1


From c78685e0c27fd15933a1aaf2733c4035aadf4e0d Mon Sep 17 00:00:00 2001
From: unknown <ram@gw.udmsearch.izhnet.ru>
Date: Tue, 28 May 2002 20:46:35 +0500
Subject: Removed unnecessary key search in the hp_rb_write_key() function

---
 mysys/tree.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'mysys')

diff --git a/mysys/tree.c b/mysys/tree.c
index 1bd49ef5182..489262fcdc7 100644
--- a/mysys/tree.c
+++ b/mysys/tree.c
@@ -86,6 +86,7 @@ void init_tree(TREE *tree, uint default_alloc_size, uint memory_limit,
   tree->custom_arg = custom_arg;
   tree->null_element.colour=BLACK;
   tree->null_element.left=tree->null_element.right=0;
+  tree->flag= 0;
   if (!free_element && size >= 0 &&
       ((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
   {
@@ -231,7 +232,11 @@ TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size,
     rb_insert(tree,parent,element);		/* rebalance tree */
   }
   else
+  {
+    if (tree->flag & TREE_NO_DUPS)
+      return(NULL);
     element->count++;
+  }
   DBUG_EXECUTE("check_tree", test_rb_tree(tree->root););
   return element;
 }
-- 
cgit v1.2.1


From 58e4105b62cbc8080a67fc9f6e6f9c9de75142af Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Fri, 31 May 2002 21:04:47 +0500
Subject: Added filling of unicode mapping arrays during charset.conf loading
 All charset.conf files were extended to supply unicode mapping array
 CONVERT() now uses more common order of arguments:
 CONVERT(expr,charset_from,charset_to) Dynamic charset can be used as
 CONVERT() argument

mysys/charset.c:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/armscii8.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/cp1251.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/cp1257.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/croat.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/danish.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/dec8.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/dos.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/estonia.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/german1.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/greek.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/hebrew.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/hp8.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/hungarian.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/koi8_ru.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/koi8_ukr.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/latin1.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/latin2.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/latin5.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/swe7.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/usa7.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/win1250.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/win1251.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/share/charsets/win1251ukr.conf:
  Added filling of unicode mapping arrays during charset.conf loading
sql/sql_yacc.yy:
  Changed the order of arguments to Convert(expr,charset_from,charset_to)
  Dynamic charsets are now resolved too for Convert() arguments
---
 mysys/charset.c | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index de6ccbf7ea9..5bc2f65468d 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -36,6 +36,7 @@ static int charset_initialized=0;
 #define TO_LOWER_TABLE_SIZE   256
 #define TO_UPPER_TABLE_SIZE   256
 #define SORT_ORDER_TABLE_SIZE 256
+#define TO_UNI_TABLE_SIZE     256
 
 struct simpleconfig_buf_st {
   FILE *f;
@@ -214,6 +215,21 @@ static my_bool fill_array(uchar *array, int sz, struct simpleconfig_buf_st *fb)
   return 0;
 }
 
+static my_bool fill_uint16_array(uint16 *array, int sz, struct simpleconfig_buf_st *fb)
+{
+  char buf[MAX_LINE];
+  while (sz--)
+  {
+    if (get_word(fb, buf))
+    {
+      DBUG_PRINT("error",("get_word failed, expecting %d more words", sz + 1));
+      return 1;
+    }
+    *array++ = (uint16) strtol(buf, NULL, 16);
+  }
+  return 0;
+}
+
 
 static void get_charset_conf_name(uint cs_number, char *buf)
 {
@@ -247,7 +263,8 @@ static my_bool read_charset_file(uint cs_number, CHARSET_INFO *set,
   if (fill_array(set->ctype,      CTYPE_TABLE_SIZE,      &fb) ||
       fill_array(set->to_lower,   TO_LOWER_TABLE_SIZE,   &fb) ||
       fill_array(set->to_upper,   TO_UPPER_TABLE_SIZE,   &fb) ||
-      fill_array(set->sort_order, SORT_ORDER_TABLE_SIZE, &fb))
+      fill_array(set->sort_order, SORT_ORDER_TABLE_SIZE, &fb) ||
+      fill_uint16_array(set->tab_to_uni,TO_UNI_TABLE_SIZE,&fb))
     result=TRUE;
 
   my_fclose(fb.f, MYF(0));
@@ -299,10 +316,11 @@ static CHARSET_INFO *find_charset_by_name(CHARSET_INFO **table,
 static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
 {
   CHARSET_INFO tmp_cs,*cs;
-  uchar tmp_ctype[CTYPE_TABLE_SIZE];
-  uchar tmp_to_lower[TO_LOWER_TABLE_SIZE];
-  uchar tmp_to_upper[TO_UPPER_TABLE_SIZE];
-  uchar tmp_sort_order[SORT_ORDER_TABLE_SIZE];
+  uchar  tmp_ctype[CTYPE_TABLE_SIZE];
+  uchar  tmp_to_lower[TO_LOWER_TABLE_SIZE];
+  uchar  tmp_to_upper[TO_UPPER_TABLE_SIZE];
+  uchar  tmp_sort_order[SORT_ORDER_TABLE_SIZE];
+  uint16 tmp_to_uni[TO_UNI_TABLE_SIZE];
 
   /* Don't allocate memory if we are not sure we can find the char set */
   cs= &tmp_cs;
@@ -311,6 +329,7 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   cs->to_lower=tmp_to_lower;
   cs->to_upper=tmp_to_upper;
   cs->sort_order=tmp_sort_order;
+  cs->tab_to_uni=tmp_to_uni;
   if (read_charset_file(cs_number, cs, flags))
     return NULL;
 
@@ -322,6 +341,7 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   cs->to_lower = (uchar*) my_once_alloc(TO_LOWER_TABLE_SIZE,   MYF(MY_WME));
   cs->to_upper = (uchar*) my_once_alloc(TO_UPPER_TABLE_SIZE,   MYF(MY_WME));
   cs->sort_order=(uchar*) my_once_alloc(SORT_ORDER_TABLE_SIZE, MYF(MY_WME));
+  cs->tab_to_uni=(uint16*)my_once_alloc(TO_UNI_TABLE_SIZE*sizeof(uint16), MYF(MY_WME));
   cs->number   = cs_number;
   memcpy((char*) cs->name,	 (char*) cs_name,	strlen(cs_name) + 1);
   memcpy((char*) cs->ctype,	 (char*) tmp_ctype,	sizeof(tmp_ctype));
@@ -329,6 +349,7 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   memcpy((char*) cs->to_upper, (char*) tmp_to_upper,	sizeof(tmp_to_upper));
   memcpy((char*) cs->sort_order, (char*) tmp_sort_order,
 	 sizeof(tmp_sort_order));
+  memcpy((char*) cs->tab_to_uni, (char*) tmp_to_uni, sizeof(tmp_to_uni));
 
   cs->caseup_str  = my_caseup_str_8bit;
   cs->casedn_str  = my_casedn_str_8bit;
@@ -336,6 +357,8 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   cs->casedn      = my_casedn_8bit;
   cs->strcasecmp  = my_strcasecmp_8bit;
   cs->strncasecmp = my_strncasecmp_8bit;
+  cs->mb_wc       = my_mb_wc_8bit;
+  cs->wc_mb       = my_wc_mb_8bit;
   
   insert_dynamic(&cs_info_table, (gptr) &cs);
   return cs;
-- 
cgit v1.2.1


From 7aef75a9a9b3f1965f1989bf224d8c9ba0090f86 Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Sun, 2 Jun 2002 21:32:02 +0500
Subject: Changed 003F -> 0000 for undefinite characters in charset.conf
 Charset convertion FROM dynamic charset is now working too Allow dynamic
 charsets in CONVERT()

mysys/charset.c:
  Charset convertion FROM dynamic charset is now working too
sql/item_strfunc.cc:
  Allow dynamic charsets in CONVERT()
sql/share/charsets/cp1251.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/cp1257.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/dec8.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/greek.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/hebrew.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/hp8.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/swe7.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/usa7.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/win1250.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/win1251.conf:
  Change 003F -> 0000 for undefinite characters
sql/share/charsets/win1251ukr.conf:
  Change 003F -> 0000 for undefinite characters
---
 mysys/charset.c | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 5bc2f65468d..d6d0c91b028 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -237,6 +237,91 @@ static void get_charset_conf_name(uint cs_number, char *buf)
           name_from_csnum(available_charsets, cs_number), ".conf", NullS);
 }
 
+typedef struct {
+	int		nchars;
+	MY_UNI_IDX	uidx;
+} uni_idx;
+
+#define PLANE_SIZE	0x100
+#define PLANE_NUM	0x100
+#define PLANE_NUMBER(x)	(((x)>>8) % PLANE_NUM)
+
+static int pcmp(const void * f, const void * s)
+{
+  const uni_idx *F=(const uni_idx*)f;
+  const uni_idx *S=(const uni_idx*)s;
+  int res;
+
+  if(!(res=((S->nchars)-(F->nchars))))
+    res=((F->uidx.from)-(S->uidx.to));
+  return res;
+}
+
+static my_bool create_fromuni(CHARSET_INFO *cs){
+  uni_idx	idx[PLANE_NUM];
+  int		i,n;
+  
+  /* Clear plane statistics */
+  bzero(idx,sizeof(idx));
+  
+  /* Count number of characters in each plane */
+  for(i=0;i<0x100;i++)
+  {
+    uint16 wc=cs->tab_to_uni[i];
+    int pl= PLANE_NUMBER(wc);
+    
+    if(wc || !i)
+    {
+      if(!idx[pl].nchars)
+      {
+        idx[pl].uidx.from=wc;
+        idx[pl].uidx.to=wc;
+      }else
+      {
+        idx[pl].uidx.from=wc<idx[pl].uidx.from?wc:idx[pl].uidx.from;
+        idx[pl].uidx.to=wc>idx[pl].uidx.to?wc:idx[pl].uidx.to;
+      }
+      idx[pl].nchars++;
+    }
+  }
+  
+  /* Sort planes in descending order */
+  qsort(&idx,PLANE_NUM,sizeof(uni_idx),&pcmp);
+  
+  for(i=0;i<PLANE_NUM;i++)
+  {
+    int ch,numchars;
+    
+    /* Skip empty plane */
+    if(!idx[i].nchars)
+      break;
+    
+    numchars=idx[i].uidx.to-idx[i].uidx.from+1;
+    idx[i].uidx.tab=(unsigned char*)my_once_alloc(numchars*sizeof(*idx[i].uidx.tab),MYF(MY_WME));
+    bzero(idx[i].uidx.tab,numchars*sizeof(*idx[i].uidx.tab));
+    
+    for(ch=1;ch<PLANE_SIZE;ch++)
+    {
+      uint16 wc=cs->tab_to_uni[ch];
+      if(wc>=idx[i].uidx.from && wc<=idx[i].uidx.to && wc)
+      {
+        int ofs=wc-idx[i].uidx.from;
+        idx[i].uidx.tab[ofs]=ch;
+      }
+    }
+  }
+  
+  /* Allocate and fill reverse table for each plane */
+  n=i;
+  cs->tab_from_uni=(MY_UNI_IDX*)my_once_alloc(sizeof(MY_UNI_IDX)*(n+1),MYF(MY_WME));
+  for(i=0;i<n;i++)
+    cs->tab_from_uni[i]=idx[i].uidx;
+  
+  /* Set end-of-list marker */
+  bzero(&cs->tab_from_uni[i],sizeof(MY_UNI_IDX));
+  return FALSE;
+}
+
 
 static my_bool read_charset_file(uint cs_number, CHARSET_INFO *set,
 				 myf myflags)
@@ -268,6 +353,7 @@ static my_bool read_charset_file(uint cs_number, CHARSET_INFO *set,
     result=TRUE;
 
   my_fclose(fb.f, MYF(0));
+  create_fromuni(set);
   DBUG_RETURN(result);
 }
 
-- 
cgit v1.2.1


From e413fd4c38735663c6122c7f7e509e3982f9296b Mon Sep 17 00:00:00 2001
From: unknown <bar@gw.udmsearch.izhnet.ru>
Date: Tue, 11 Jun 2002 21:04:14 +0500
Subject: test_charset.c:   fix: use my_free() instead of free()

mysys/test_charset.c:
  fix: use my_free() instead of free()
---
 mysys/test_charset.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'mysys')

diff --git a/mysys/test_charset.c b/mysys/test_charset.c
index 15e46f3ff82..224a4120614 100644
--- a/mysys/test_charset.c
+++ b/mysys/test_charset.c
@@ -48,11 +48,11 @@ int main(int argc, char **argv) {
 
   cs_list = list_charsets(MYF(MY_COMPILED_SETS | MY_CONFIG_SETS));
   printf("LIST OF CHARSETS (compiled + *.conf):\n%s\n", cs_list);
-  free(cs_list);
+  my_free(cs_list,MYF(0));
 
   cs_list = list_charsets(MYF(MY_INDEX_SETS | MY_LOADED_SETS));
   printf("LIST OF CHARSETS (index + loaded):\n%s\n", cs_list);
-  free(cs_list);
+  my_free(cs_list,MYF(0));
 
   return 0;
 }
-- 
cgit v1.2.1


From ebdc990b69455548fa412a22286b302f0c1a1322 Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Tue, 30 Jul 2002 11:03:08 +0500
Subject: move _print_charset to proper place

---
 mysys/charset.c      | 38 --------------------------------------
 mysys/test_charset.c | 33 ++++++++++++++++++++++++++++++++-
 2 files changed, 32 insertions(+), 39 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 94cd1d9f9f8..0178f346dbe 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -634,41 +634,3 @@ char * list_charsets(myf want_flags)
 
   return p;
 }
-
-/****************************************************************************
-* Code for debugging.
-****************************************************************************/
-
-
-static void _print_array(uint8 *data, uint size)
-{
-  uint i;
-  for (i = 0; i < size; ++i)
-  {
-    if (i == 0 || i % 16 == size % 16) printf("  ");
-    printf(" %02x", data[i]);
-    if ((i+1) % 16 == size % 16) printf("\n");
-  }
-}
-
-/* _print_csinfo is called from test_charset.c */
-void _print_csinfo(CHARSET_INFO *cs)
-{
-  printf("%s #%d\n", cs->name, cs->number);
-  printf("ctype:\n"); _print_array(cs->ctype, 257);
-  printf("to_lower:\n"); _print_array(cs->to_lower, 256);
-  printf("to_upper:\n"); _print_array(cs->to_upper, 256);
-  printf("sort_order:\n"); _print_array(cs->sort_order, 256);
-  printf("collate:    %3s (%d, %p, %p, %p)\n",
-         cs->strxfrm_multiply ? "yes" : "no",
-         cs->strxfrm_multiply,
-         cs->strnncoll,
-         cs->strnxfrm,
-         cs->like_range);
-  printf("multi-byte: %3s (%d, %p, %p, %p)\n",
-         cs->mbmaxlen ? "yes" : "no",
-         cs->mbmaxlen,
-         cs->ismbchar,
-         cs->ismbhead,
-         cs->mbcharlen);
-}
diff --git a/mysys/test_charset.c b/mysys/test_charset.c
index 224a4120614..5e623584355 100644
--- a/mysys/test_charset.c
+++ b/mysys/test_charset.c
@@ -21,7 +21,38 @@
 
 #include <stdio.h>
 
-extern void _print_csinfo(CHARSET_INFO *cs);
+static void _print_array(uint8 *data, uint size)
+{
+  uint i;
+  for (i = 0; i < size; ++i)
+  {
+    if (i == 0 || i % 16 == size % 16) printf("  ");
+    printf(" %02x", data[i]);
+    if ((i+1) % 16 == size % 16) printf("\n");
+  }
+}
+
+static void _print_csinfo(CHARSET_INFO *cs)
+{
+  printf("%s #%d\n", cs->name, cs->number);
+  printf("ctype:\n"); _print_array(cs->ctype, 257);
+  printf("to_lower:\n"); _print_array(cs->to_lower, 256);
+  printf("to_upper:\n"); _print_array(cs->to_upper, 256);
+  printf("sort_order:\n"); _print_array(cs->sort_order, 256);
+  printf("collate:    %3s (%d, %p, %p, %p)\n",
+         cs->strxfrm_multiply ? "yes" : "no",
+         cs->strxfrm_multiply,
+         cs->strnncoll,
+         cs->strnxfrm,
+         cs->like_range);
+  printf("multi-byte: %3s (%d, %p, %p, %p)\n",
+         cs->mbmaxlen ? "yes" : "no",
+         cs->mbmaxlen,
+         cs->ismbchar,
+         cs->ismbhead,
+         cs->mbcharlen);
+}
+
 
 int main(int argc, char **argv) {
   const char *the_set = MYSQL_CHARSET;
-- 
cgit v1.2.1


From fcaf867bb93d188397cb4788b6204283a8af39d3 Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Tue, 30 Jul 2002 14:02:29 +0500
Subject: Renamed some charset related constant New fields in CHARSET_INFO for
 more nice SHOW CHARACTER SET Dynamic charsets are now handled in faster way
 SHOW CHARACTER SET now displays not only compiled charsets but dynamic
 charsets too

include/m_ctype.h:
  Renamed constant
  New fields in CHARSET_INFO
include/my_sys.h:
  Constant have been moved to m_ctype.h
libmysqld/lib_sql.cc:
  Renamed constant
mysys/charset.c:
  Dynamic charsets are now handled in new way to speedup things
mysys/test_charset.c:
  Renamed constant
sql/mysqld.cc:
  Renamed constant
sql/sql_show.cc:
  SHOW CHARACTER SET now displays not only compiled charsets but dynamic charsets too
strings/ctype.c:
  New fields in CHARSET_INFO
---
 mysys/charset.c      | 232 +++++++++++++++++++++------------------------------
 mysys/test_charset.c |   4 +-
 2 files changed, 95 insertions(+), 141 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 0178f346dbe..8c05863c44b 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -26,9 +26,8 @@ typedef struct cs_id_st {
 } CS_ID;
 
 const char *charsets_dir = NULL;
-static DYNAMIC_ARRAY cs_info_table;
-static CS_ID **available_charsets;
 static int charset_initialized=0;
+CHARSET_INFO all_charsets[256];
 
 #define MAX_LINE  1024
 
@@ -44,24 +43,6 @@ struct simpleconfig_buf_st {
   char *p;
 };
 
-static uint num_from_csname(CS_ID **cs, const char *name)
-{
-  CS_ID **c;
-  for (c = cs; *c; ++c)
-    if (!strcmp((*c)->name, name))
-      return (*c)->number;
-  return 0;   /* this mimics find_type() */
-}
-
-static char *name_from_csnum(CS_ID **cs, uint number)
-{
-  CS_ID **c;
-  if(cs)
-    for (c = cs; *c; ++c)
-      if ((*c)->number == number)
-	return (*c)->name;
-  return (char*) "?";   /* this mimics find_type() */
-}
 
 static my_bool get_word(struct simpleconfig_buf_st *fb, char *buf)
 {
@@ -109,13 +90,11 @@ char *get_charsets_dir(char *buf)
 }
 
 
-static my_bool read_charset_index(CS_ID ***charsets, myf myflags)
+static my_bool read_charset_index(myf myflags)
 {
   struct simpleconfig_buf_st fb;
   char buf[MAX_LINE], num_buf[MAX_LINE];
-  DYNAMIC_ARRAY cs;
-  CS_ID *csid;
-
+    
   strmov(get_charsets_dir(buf), "Index");
 
   if ((fb.f = my_fopen(buf, O_RDONLY, myflags)) == NULL)
@@ -123,13 +102,12 @@ static my_bool read_charset_index(CS_ID ***charsets, myf myflags)
   fb.buf[0] = '\0';
   fb.p = fb.buf;
 
-  if (my_init_dynamic_array(&cs, sizeof(CS_ID *), 32, 32))
-    return TRUE;
-
+  
   while (!get_word(&fb, buf) && !get_word(&fb, num_buf))
   {
     uint csnum;
     uint length;
+    CHARSET_INFO *cs;
 
     if (!(csnum = atoi(num_buf)))
     {
@@ -138,64 +116,56 @@ static my_bool read_charset_index(CS_ID ***charsets, myf myflags)
       return TRUE;
     }
 
-    if (!(csid = (CS_ID*) my_once_alloc(sizeof(CS_ID), myflags)) ||
-        !(csid->name=
+    cs=&all_charsets[csnum];
+    
+    if (!(cs->name=
            (char*) my_once_alloc(length= (uint) strlen(buf)+1, myflags)))
     {
       my_fclose(fb.f,myflags);
       return TRUE;
     }
-    memcpy(csid->name,buf,length);
-    csid->number = csnum;
-
-    insert_dynamic(&cs, (gptr) &csid);
+    memcpy((char*)cs->name,buf,length);
+    cs->number=csnum;
   }
   my_fclose(fb.f,myflags);
 
-
-  if (!(*charsets =
-      (CS_ID **) my_once_alloc((cs.elements + 1) * sizeof(CS_ID *), myflags)))
-    return TRUE;
-  /* unwarranted chumminess with dynamic_array implementation? */
-  memcpy((byte *) *charsets, cs.buffer, cs.elements * sizeof(CS_ID *));
-  (*charsets)[cs.elements] = NULL;
-  delete_dynamic(&cs);  
-
   return FALSE;
 }
 
 
 static my_bool init_available_charsets(myf myflags)
 {
-  my_bool error=0;
+  my_bool error=FALSE;
   /*
     We have to use charset_initialized to not lock on THR_LOCK_charset
     inside get_internal_charset...
    */
   if (!charset_initialized)
   {
+    CHARSET_INFO *cs;
   /*
     To make things thread safe we are not allowing other threads to interfere
     while we may changing the cs_info_table
   */
     pthread_mutex_lock(&THR_LOCK_charset);
-    if (!cs_info_table.buffer)			/* If not initialized */
-    {
-      my_init_dynamic_array(&cs_info_table, sizeof(CHARSET_INFO*), 16, 8);
-      error = read_charset_index(&available_charsets, myflags);
-    }
+
+    bzero(&all_charsets,sizeof(all_charsets));
+    
+    /* Copy compiled charsets */
+    
+    for (cs=compiled_charsets; cs->name; cs++)
+      all_charsets[cs->number]=cs[0];
+    
+    error = read_charset_index(myflags);
     charset_initialized=1;
     pthread_mutex_unlock(&THR_LOCK_charset);
   }
-  if(!available_charsets || !available_charsets[0])
-    error = TRUE;
   return error;
 }
 
 
 void free_charsets(void)
 {
-  delete_dynamic(&cs_info_table);
   charset_initialized=0;
 }
 
@@ -231,10 +201,9 @@ static my_bool fill_uint16_array(uint16 *array, int sz, struct simpleconfig_buf_
 }
 
 
-static void get_charset_conf_name(uint cs_number, char *buf)
+static void get_charset_conf_name(const char *cs_name, char *buf)
 {
-  strxmov(get_charsets_dir(buf),
-          name_from_csnum(available_charsets, cs_number), ".conf", NullS);
+  strxmov(get_charsets_dir(buf), cs_name, ".conf", NullS);
 }
 
 typedef struct {
@@ -323,19 +292,16 @@ static my_bool create_fromuni(CHARSET_INFO *cs){
 }
 
 
-static my_bool read_charset_file(uint cs_number, CHARSET_INFO *set,
+static my_bool read_charset_file(const char *cs_name, CHARSET_INFO *set,
 				 myf myflags)
 {
   struct simpleconfig_buf_st fb;
   char buf[FN_REFLEN];
   my_bool result;
   DBUG_ENTER("read_charset_file");
-  DBUG_PRINT("enter",("cs_number: %d", cs_number));
-
-  if (cs_number <= 0)
-    DBUG_RETURN(TRUE);
+  DBUG_PRINT("enter",("cs_name: %s", cs_name));
 
-  get_charset_conf_name(cs_number, buf);
+  get_charset_conf_name(cs_name, buf);
   DBUG_PRINT("info",("file name: %s", buf));
 
   if ((fb.f = my_fopen(buf, O_RDONLY, myflags)) == NULL)
@@ -358,70 +324,26 @@ static my_bool read_charset_file(uint cs_number, CHARSET_INFO *set,
 }
 
 
-uint get_charset_number(const char *charset_name)
-{
-  uint number=compiled_charset_number(charset_name);
-  if (number)
-    return number;
-  if (init_available_charsets(MYF(0)))	/* If it isn't initialized */
-    return 0;
-  return num_from_csname(available_charsets, charset_name);
-}
-
-const char *get_charset_name(uint charset_number)
-{
-  const char *name=compiled_charset_name(charset_number);
-  if (*name != '?')
-    return name;
-  if (init_available_charsets(MYF(0)))	/* If it isn't initialized */
-    return "?";
-  return name_from_csnum(available_charsets, charset_number);
-}
-
-
-static CHARSET_INFO *find_charset(CHARSET_INFO **table, uint cs_number,
-                                  size_t tablesz)
-{
-  uint i;
-  for (i = 0; i < tablesz; ++i)
-    if (table[i]->number == cs_number)
-      return table[i];
-  return NULL;
-}
-
-static CHARSET_INFO *find_charset_by_name(CHARSET_INFO **table,
-					  const char *name, size_t tablesz)
-{
-  uint i;
-  for (i = 0; i < tablesz; ++i)
-    if (!strcmp(table[i]->name,name))
-      return table[i];
-  return NULL;
-}
-
 static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
 {
-  CHARSET_INFO tmp_cs,*cs;
+  CHARSET_INFO *cs;
   uchar  tmp_ctype[CTYPE_TABLE_SIZE];
   uchar  tmp_to_lower[TO_LOWER_TABLE_SIZE];
   uchar  tmp_to_upper[TO_UPPER_TABLE_SIZE];
   uchar  tmp_sort_order[SORT_ORDER_TABLE_SIZE];
   uint16 tmp_to_uni[TO_UNI_TABLE_SIZE];
 
-  /* Don't allocate memory if we are not sure we can find the char set */
-  cs= &tmp_cs;
+  cs=&all_charsets[cs_number];
   bzero((char*) cs, sizeof(*cs));
   cs->ctype=tmp_ctype;
   cs->to_lower=tmp_to_lower;
   cs->to_upper=tmp_to_upper;
   cs->sort_order=tmp_sort_order;
   cs->tab_to_uni=tmp_to_uni;
-  if (read_charset_file(cs_number, cs, flags))
+  if (read_charset_file(cs_name, cs, flags))
     return NULL;
 
-  cs           = (CHARSET_INFO*) my_once_alloc(sizeof(CHARSET_INFO),
-                                               MYF(MY_WME));
-  *cs=tmp_cs;
+  /* FIXME: double allocation */
   cs->name     = (char *) my_once_alloc((uint) strlen(cs_name)+1, MYF(MY_WME));
   cs->ctype    = (uchar*) my_once_alloc(CTYPE_TABLE_SIZE,      MYF(MY_WME));
   cs->to_lower = (uchar*) my_once_alloc(TO_LOWER_TABLE_SIZE,   MYF(MY_WME));
@@ -446,10 +368,38 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   cs->mb_wc       = my_mb_wc_8bit;
   cs->wc_mb       = my_wc_mb_8bit;
   
-  insert_dynamic(&cs_info_table, (gptr) &cs);
   return cs;
 }
 
+
+uint get_charset_number(const char *charset_name)
+{
+  CHARSET_INFO *cs;
+  if (init_available_charsets(MYF(0)))	/* If it isn't initialized */
+    return 0;
+  
+  for (cs = all_charsets; cs < all_charsets+255; ++cs)
+    if ( cs->name && !strcmp(cs->name, charset_name))
+      return cs->number;
+  
+  return 0;   /* this mimics find_type() */
+}
+
+
+const char *get_charset_name(uint charset_number)
+{
+  CHARSET_INFO *cs;
+  if (init_available_charsets(MYF(0)))	/* If it isn't initialized */
+    return "?";
+
+  for (cs = all_charsets; cs < all_charsets+255; ++cs)
+    if (cs->number == charset_number)
+      return (char*) cs->name;
+
+  return (char*) "?";   /* this mimics find_type() */
+}
+
+
 static CHARSET_INFO *get_internal_charset(uint cs_number, myf flags)
 {
   CHARSET_INFO *cs;
@@ -458,10 +408,10 @@ static CHARSET_INFO *get_internal_charset(uint cs_number, myf flags)
     while we may changing the cs_info_table
   */
   pthread_mutex_lock(&THR_LOCK_charset);
-  if (!(cs = find_charset((CHARSET_INFO**) cs_info_table.buffer, cs_number,
-			  cs_info_table.elements)))
-    if (!(cs = find_compiled_charset(cs_number)))
-      cs=add_charset(cs_number, get_charset_name(cs_number), flags);
+
+  if (!(cs = find_compiled_charset(cs_number)))
+    cs=add_charset(cs_number, get_charset_name(cs_number), flags);
+  
   pthread_mutex_unlock(&THR_LOCK_charset);
   return cs;
 }
@@ -475,10 +425,10 @@ static CHARSET_INFO *get_internal_charset_by_name(const char *name, myf flags)
     while we may changing the cs_info_table
   */
   pthread_mutex_lock(&THR_LOCK_charset);
-  if (!(cs = find_charset_by_name((CHARSET_INFO**) cs_info_table.buffer, name,
-				 cs_info_table.elements)))
-    if (!(cs = find_compiled_charset_by_name(name)))
-      cs=add_charset(get_charset_number(name), name, flags);
+
+  if (!(cs = find_compiled_charset_by_name(name)))
+    cs=add_charset(get_charset_number(name), name, flags);
+
   pthread_mutex_unlock(&THR_LOCK_charset);
   return cs;
 }
@@ -585,7 +535,7 @@ char * list_charsets(myf want_flags)
   (void)init_available_charsets(MYF(0));
   init_dynamic_string(&s, NullS, 256, 1024);
 
-  if (want_flags & MY_COMPILED_SETS)
+  if (want_flags & MY_CS_COMPILED)
   {
     CHARSET_INFO *cs;
     for (cs = compiled_charsets; cs->number > 0; cs++)
@@ -595,39 +545,43 @@ char * list_charsets(myf want_flags)
     }
   }
 
-  if (want_flags & MY_CONFIG_SETS)
+  if (want_flags & MY_CS_CONFIG)
   {
-    CS_ID **c;
+    CHARSET_INFO *cs;
     char buf[FN_REFLEN];
     MY_STAT status;
 
-    if((c=available_charsets))
-      for (; *c; ++c)
-	{
-	  if (charset_in_string((*c)->name, &s))
-	    continue;
-	  get_charset_conf_name((*c)->number, buf);
-	  if (!my_stat(buf, &status, MYF(0)))
-	    continue;       /* conf file doesn't exist */
-	  dynstr_append(&s, (*c)->name);
-	  dynstr_append(&s, " ");
-	}
+    for (cs=all_charsets; cs < all_charsets+255; cs++)
+    {
+      if (!cs->name || charset_in_string(cs->name, &s))
+	continue;
+      get_charset_conf_name(cs->name, buf);
+      if (!my_stat(buf, &status, MYF(0)))
+	continue;       /* conf file doesn't exist */
+      dynstr_append(&s, cs->name);
+      dynstr_append(&s, " ");
+    }
   }
 
-  if (want_flags & MY_INDEX_SETS)
+  if (want_flags & MY_CS_INDEX)
   {
-    CS_ID **c;
-    for (c = available_charsets; *c; ++c)
-      charset_append(&s, (*c)->name);
+    CHARSET_INFO *cs;
+    for (cs = all_charsets; cs < all_charsets + 255; cs++)
+      if (cs->name)
+        charset_append(&s, cs->name);
   }
 
+#if 0
   if (want_flags & MY_LOADED_SETS)
   {
-    uint i;
-    for (i = 0; i < cs_info_table.elements; i++)
-      charset_append(&s, 
-		     dynamic_element(&cs_info_table, i, CHARSET_INFO *)->name);
+    CHARSET_INFO *cs;
+    /* FIXME */
+    for (cs = all_charsets; cs < all_charsets + 255; cs++)
+      if (cs->name)
+        charset_append(&s, cs->name);
   }
+#endif
+
   s.str[s.length - 1] = '\0';   /* chop trailing space */
   p = my_strdup(s.str, MYF(MY_WME));
   dynstr_free(&s);
diff --git a/mysys/test_charset.c b/mysys/test_charset.c
index 5e623584355..47ed9062c05 100644
--- a/mysys/test_charset.c
+++ b/mysys/test_charset.c
@@ -77,11 +77,11 @@ int main(int argc, char **argv) {
   _print_csinfo(default_charset_info);
   fflush(stdout);
 
-  cs_list = list_charsets(MYF(MY_COMPILED_SETS | MY_CONFIG_SETS));
+  cs_list = list_charsets(MYF(MY_CS_COMPILED | MY_CS_CONFIG));
   printf("LIST OF CHARSETS (compiled + *.conf):\n%s\n", cs_list);
   my_free(cs_list,MYF(0));
 
-  cs_list = list_charsets(MYF(MY_INDEX_SETS | MY_LOADED_SETS));
+  cs_list = list_charsets(MYF(MY_CS_INDEX | MY_CS_LOADED));
   printf("LIST OF CHARSETS (index + loaded):\n%s\n", cs_list);
   my_free(cs_list,MYF(0));
 
-- 
cgit v1.2.1


From 08047dcccdb5b6fab276a53f334b117464a29ddb Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Tue, 30 Jul 2002 17:12:51 +0500
Subject: Removed unused strucure Some fixes and improvements

---
 mysys/charset.c | 82 +++++++++++++++++++++++++++------------------------------
 1 file changed, 39 insertions(+), 43 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index 8c05863c44b..cd84194dab1 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -20,10 +20,6 @@
 #include <m_string.h>
 #include <my_dir.h>
 
-typedef struct cs_id_st {
-  char *name;
-  uint number;
-} CS_ID;
 
 const char *charsets_dir = NULL;
 static int charset_initialized=0;
@@ -324,7 +320,7 @@ static my_bool read_charset_file(const char *cs_name, CHARSET_INFO *set,
 }
 
 
-static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
+static CHARSET_INFO *add_charset(uint cs_number, myf flags)
 {
   CHARSET_INFO *cs;
   uchar  tmp_ctype[CTYPE_TABLE_SIZE];
@@ -333,25 +329,24 @@ static CHARSET_INFO *add_charset(uint cs_number, const char *cs_name, myf flags)
   uchar  tmp_sort_order[SORT_ORDER_TABLE_SIZE];
   uint16 tmp_to_uni[TO_UNI_TABLE_SIZE];
 
+  /* Note: cs->name is already initialized */
+  
   cs=&all_charsets[cs_number];
-  bzero((char*) cs, sizeof(*cs));
+
   cs->ctype=tmp_ctype;
   cs->to_lower=tmp_to_lower;
   cs->to_upper=tmp_to_upper;
   cs->sort_order=tmp_sort_order;
   cs->tab_to_uni=tmp_to_uni;
-  if (read_charset_file(cs_name, cs, flags))
+  if (read_charset_file(cs->name, cs, flags))
     return NULL;
 
-  /* FIXME: double allocation */
-  cs->name     = (char *) my_once_alloc((uint) strlen(cs_name)+1, MYF(MY_WME));
   cs->ctype    = (uchar*) my_once_alloc(CTYPE_TABLE_SIZE,      MYF(MY_WME));
   cs->to_lower = (uchar*) my_once_alloc(TO_LOWER_TABLE_SIZE,   MYF(MY_WME));
   cs->to_upper = (uchar*) my_once_alloc(TO_UPPER_TABLE_SIZE,   MYF(MY_WME));
   cs->sort_order=(uchar*) my_once_alloc(SORT_ORDER_TABLE_SIZE, MYF(MY_WME));
   cs->tab_to_uni=(uint16*)my_once_alloc(TO_UNI_TABLE_SIZE*sizeof(uint16), MYF(MY_WME));
   cs->number   = cs_number;
-  memcpy((char*) cs->name,	 (char*) cs_name,	strlen(cs_name) + 1);
   memcpy((char*) cs->ctype,	 (char*) tmp_ctype,	sizeof(tmp_ctype));
   memcpy((char*) cs->to_lower, (char*) tmp_to_lower,	sizeof(tmp_to_lower));
   memcpy((char*) cs->to_upper, (char*) tmp_to_upper,	sizeof(tmp_to_upper));
@@ -392,10 +387,10 @@ const char *get_charset_name(uint charset_number)
   if (init_available_charsets(MYF(0)))	/* If it isn't initialized */
     return "?";
 
-  for (cs = all_charsets; cs < all_charsets+255; ++cs)
-    if (cs->number == charset_number)
-      return (char*) cs->name;
-
+  cs=&all_charsets[charset_number];
+  if ( (cs->number==charset_number) && cs->name )
+    return (char*) cs->name;
+  
   return (char*) "?";   /* this mimics find_type() */
 }
 
@@ -409,8 +404,18 @@ static CHARSET_INFO *get_internal_charset(uint cs_number, myf flags)
   */
   pthread_mutex_lock(&THR_LOCK_charset);
 
-  if (!(cs = find_compiled_charset(cs_number)))
-    cs=add_charset(cs_number, get_charset_name(cs_number), flags);
+  
+/*
+  FIXME: it's faster to use this code, but max_sort_char is
+  not initialized here, so LIKE doesn't work later
+  
+  cs = &all_charsets[cs_number];
+  if (!(cs->state & (MY_CS_COMPILED | MY_CS_LOADED)))
+    cs=add_charset(cs_number, flags);
+*/
+  
+  if (!(cs=find_compiled_charset(cs_number)))
+    cs=add_charset(cs_number, flags);
   
   pthread_mutex_unlock(&THR_LOCK_charset);
   return cs;
@@ -419,25 +424,20 @@ static CHARSET_INFO *get_internal_charset(uint cs_number, myf flags)
 
 static CHARSET_INFO *get_internal_charset_by_name(const char *name, myf flags)
 {
-  CHARSET_INFO *cs;
-  /*
-    To make things thread safe we are not allowing other threads to interfere
-    while we may changing the cs_info_table
-  */
-  pthread_mutex_lock(&THR_LOCK_charset);
-
-  if (!(cs = find_compiled_charset_by_name(name)))
-    cs=add_charset(get_charset_number(name), name, flags);
-
-  pthread_mutex_unlock(&THR_LOCK_charset);
-  return cs;
+  uint cs_number=get_charset_number(name);
+  return cs_number ? get_internal_charset(cs_number,flags) : NULL;
 }
 
 
+
 CHARSET_INFO *get_charset(uint cs_number, myf flags)
 {
   CHARSET_INFO *cs;
   (void) init_available_charsets(MYF(0));	/* If it isn't initialized */
+  
+  if (!cs_number)
+    return NULL;
+  
   cs=get_internal_charset(cs_number, flags);
 
   if (!cs && (flags & MY_WME))
@@ -563,28 +563,24 @@ char * list_charsets(myf want_flags)
     }
   }
 
-  if (want_flags & MY_CS_INDEX)
+  if (want_flags & (MY_CS_INDEX|MY_CS_LOADED))
   {
     CHARSET_INFO *cs;
     for (cs = all_charsets; cs < all_charsets + 255; cs++)
-      if (cs->name)
+      if (cs->name && (cs->state & want_flags) )
         charset_append(&s, cs->name);
   }
-
-#if 0
-  if (want_flags & MY_LOADED_SETS)
+  
+  if (s.length)
   {
-    CHARSET_INFO *cs;
-    /* FIXME */
-    for (cs = all_charsets; cs < all_charsets + 255; cs++)
-      if (cs->name)
-        charset_append(&s, cs->name);
+    s.str[s.length - 1] = '\0';   /* chop trailing space */
+    p = my_strdup(s.str, MYF(MY_WME));
+  }
+  else
+  {
+    p = my_strdup("", MYF(MY_WME));
   }
-#endif
-
-  s.str[s.length - 1] = '\0';   /* chop trailing space */
-  p = my_strdup(s.str, MYF(MY_WME));
   dynstr_free(&s);
-
+  
   return p;
 }
-- 
cgit v1.2.1


From 5d61c21aa9716544df6fce044ec27d8ce771c9d9 Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Wed, 31 Jul 2002 13:25:37 +0500
Subject: Some more speedup in charsets handling

sql/init.cc:
  This code is moved to more proper place in mysys/charset.c
---
 mysys/charset.c | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index cd84194dab1..c1a61ad693f 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -128,6 +128,24 @@ static my_bool read_charset_index(myf myflags)
   return FALSE;
 }
 
+static void set_max_sort_char(CHARSET_INFO *cs)
+{
+  uchar max_char;
+  uint  i;
+  
+  if (!cs->sort_order)
+    return;
+  
+  max_char=cs->sort_order[(uchar) cs->max_sort_char];
+  for (i = 0; i < 256; i++)
+  {
+    if ((uchar) cs->sort_order[i] > max_char)
+    {
+      max_char=(uchar) cs->sort_order[i];
+      cs->max_sort_char= (char) i;
+    }
+  }
+}
 
 static my_bool init_available_charsets(myf myflags)
 {
@@ -150,8 +168,10 @@ static my_bool init_available_charsets(myf myflags)
     /* Copy compiled charsets */
     
     for (cs=compiled_charsets; cs->name; cs++)
+    {
       all_charsets[cs->number]=cs[0];
-    
+      set_max_sort_char(&all_charsets[cs->number]);
+    }
     error = read_charset_index(myflags);
     charset_initialized=1;
     pthread_mutex_unlock(&THR_LOCK_charset);
@@ -363,6 +383,8 @@ static CHARSET_INFO *add_charset(uint cs_number, myf flags)
   cs->mb_wc       = my_mb_wc_8bit;
   cs->wc_mb       = my_wc_mb_8bit;
   
+  set_max_sort_char(cs);
+  
   return cs;
 }
 
@@ -404,19 +426,10 @@ static CHARSET_INFO *get_internal_charset(uint cs_number, myf flags)
   */
   pthread_mutex_lock(&THR_LOCK_charset);
 
-  
-/*
-  FIXME: it's faster to use this code, but max_sort_char is
-  not initialized here, so LIKE doesn't work later
-  
   cs = &all_charsets[cs_number];
   if (!(cs->state & (MY_CS_COMPILED | MY_CS_LOADED)))
     cs=add_charset(cs_number, flags);
-*/
-  
-  if (!(cs=find_compiled_charset(cs_number)))
-    cs=add_charset(cs_number, flags);
-  
+
   pthread_mutex_unlock(&THR_LOCK_charset);
   return cs;
 }
-- 
cgit v1.2.1


From b4a63d5137d8580676d9c76d367a173d94d6a0fd Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Wed, 31 Jul 2002 17:34:27 +0500
Subject: Move operation to logically better place

---
 mysys/charset.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'mysys')

diff --git a/mysys/charset.c b/mysys/charset.c
index c1a61ad693f..691a4233269 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -335,7 +335,6 @@ static my_bool read_charset_file(const char *cs_name, CHARSET_INFO *set,
     result=TRUE;
 
   my_fclose(fb.f, MYF(0));
-  create_fromuni(set);
   DBUG_RETURN(result);
 }
 
@@ -384,6 +383,7 @@ static CHARSET_INFO *add_charset(uint cs_number, myf flags)
   cs->wc_mb       = my_wc_mb_8bit;
   
   set_max_sort_char(cs);
+  create_fromuni(cs);
   
   return cs;
 }
-- 
cgit v1.2.1


From 1e5e67272cbafa576fe556ef6c20f5f9f9d5acdf Mon Sep 17 00:00:00 2001
From: unknown <serg@sergbook.mysql.com>
Date: Mon, 5 Aug 2002 09:41:48 +0200
Subject: make SEARCH_PREFIX to work with complex (use_strcoll) charsets

---
 mysys/my_handler.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'mysys')

diff --git a/mysys/my_handler.c b/mysys/my_handler.c
index 1e7d8a702d2..5b68b427f3a 100644
--- a/mysys/my_handler.c
+++ b/mysys/my_handler.c
@@ -25,7 +25,8 @@ int mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
 #ifdef USE_STRCOLL
   if (use_strcoll(charset_info))
   {
-    /* QQ: This needs to work with part keys at some point */
+    if (part_key && b_length < a_length)
+      a_length=b_length;
     return my_strnncoll(charset_info, a, a_length, b, b_length);
   }
   else
-- 
cgit v1.2.1


From 29c723c8cfd3bb45a93f73081e7d542e5e76394a Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.udmsearch.izhnet.ru>
Date: Tue, 6 Aug 2002 15:47:52 +0500
Subject: New file to generate a html page to review a charset

BitKeeper/etc/ignore:
  Added mysys/charset2html to the ignore list
---
 mysys/Makefile.am    |   6 +++-
 mysys/charset2html.c | 100 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 105 insertions(+), 1 deletion(-)
 create mode 100644 mysys/charset2html.c

(limited to 'mysys')

diff --git a/mysys/Makefile.am b/mysys/Makefile.am
index ec8a6b33224..4386a0cac76 100644
--- a/mysys/Makefile.am
+++ b/mysys/Makefile.am
@@ -53,10 +53,11 @@ EXTRA_DIST =		thr_alarm.c thr_lock.c my_pthread.c my_thr_init.c \
 			thr_mutex.c thr_rwlock.c
 libmysys_a_LIBADD =	@THREAD_LOBJECTS@
 # test_fn removed 980815 since it not upp to date test_dir
-noinst_PROGRAMS =	test_charset @THREAD_LPROGRAMS@
+noinst_PROGRAMS =	test_charset charset2html @THREAD_LPROGRAMS@
 # test_dir_DEPENDENCIES=	$(LIBRARIES)
 # testhash_DEPENDENCIES=	$(LIBRARIES)
 test_charset_DEPENDENCIES=	$(LIBRARIES)
+charset2html_DEPENDENCIES=	$(LIBRARIES)
 EXTRA_PROGRAMS =	
 DEFS =			-DDEFAULT_BASEDIR=\"$(prefix)\" \
 			-DDATADIR="\"$(MYSQLDATAdir)\"" \
@@ -109,6 +110,9 @@ test_dir: test_dir.c $(LIBRARIES)
 test_charset: test_charset.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN $(srcdir)/test_charset.c $(LDADD) $(LIBS)
 
+charset2html: charset2html.c $(LIBRARIES)
+	$(LINK) $(FLAGS) -DMAIN $(srcdir)/charset2html.c $(LDADD) $(LIBS)
+
 testhash: testhash.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN $(srcdir)/testhash.c $(LDADD) $(LIBS)
 
diff --git a/mysys/charset2html.c b/mysys/charset2html.c
new file mode 100644
index 00000000000..9a8fbe2b68f
--- /dev/null
+++ b/mysys/charset2html.c
@@ -0,0 +1,100 @@
+/* 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; either version 2 of the License, or
+   (at your option) any later version.
+
+   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 
+ */
+
+/*
+  Written by Alexander Barkov to check what 
+  a charset is in your favorite web browser
+*/
+
+#include <my_global.h>
+#include <m_ctype.h>
+#include <my_sys.h>
+#include <mysql_version.h>
+
+#include <stdio.h>
+
+typedef struct char_info_st 
+{
+  int srt;
+  int uni;
+  int low;
+  int upp;
+  int ctp;
+} MY_CH;
+
+static int chcmp(const void *vf, const void *vs)
+{
+  const MY_CH *f=vf;
+  const MY_CH *s=vs;
+  
+  return f->srt-s->srt ? f->srt-s->srt : f->uni-s->uni;
+}
+ 
+static void print_cs(CHARSET_INFO *cs)
+{
+  uint i;
+  MY_CH ch[256];
+  
+  printf("<HTML>\n");
+  printf("<HEAD>\n");
+  printf("</HEAD>\n");
+  printf("<BODY><PRE>\n");
+  printf("Charset %s\n",cs->name);
+  
+  for (i=0; i<256; i++)
+  {
+    ch[i].srt=cs->sort_order[i];
+    ch[i].uni=cs->tab_to_uni[i];
+    ch[i].low=cs->tab_to_uni[cs->to_lower[i]];
+    ch[i].upp=cs->tab_to_uni[cs->to_upper[i]];
+    ch[i].ctp=cs->ctype[i+1];
+  }
+  
+  qsort(ch,256,sizeof(MY_CH),&chcmp);
+   
+  for (i=1; i<256; i++)
+  {
+    printf("%d %d &#%d; &#%d; &#%d;\n",ch[i].srt,ch[i].ctp,ch[i].uni,
+    				       ch[i].low,ch[i].upp);
+  }
+  printf("</PRE></BODY>\n");
+  printf("</HTML>\n");
+}
+
+
+int main(int argc, char **argv) {
+  const char *the_set = MYSQL_CHARSET;
+  int argcnt = 1;
+
+  my_init();
+
+  if (argc > argcnt && argv[argcnt][0] == '-' && argv[argcnt][1] == '#')
+    DBUG_PUSH(argv[argcnt++]+2);
+
+  if (argc > argcnt)
+    the_set = argv[argcnt++];
+
+  if (argc > argcnt)
+    charsets_dir = argv[argcnt++];
+
+  if (set_default_charset_by_name(the_set, MYF(MY_WME)))
+    return 1;
+
+  print_cs(default_charset_info);
+
+  return 0;
+}
-- 
cgit v1.2.1


From 91ff2ebebe051ff3effb67d988beb4a721ac84a6 Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.mysql.r18.ru>
Date: Wed, 14 Aug 2002 20:48:39 +0500
Subject: More readable output

---
 mysys/charset2html.c | 43 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 7 deletions(-)

(limited to 'mysys')

diff --git a/mysys/charset2html.c b/mysys/charset2html.c
index 9a8fbe2b68f..0d6450a8116 100644
--- a/mysys/charset2html.c
+++ b/mysys/charset2html.c
@@ -29,6 +29,7 @@
 
 typedef struct char_info_st 
 {
+  int cod;
   int srt;
   int uni;
   int low;
@@ -43,20 +44,26 @@ static int chcmp(const void *vf, const void *vs)
   
   return f->srt-s->srt ? f->srt-s->srt : f->uni-s->uni;
 }
- 
+
 static void print_cs(CHARSET_INFO *cs)
 {
-  uint i;
+  uint  i;
+  int   srt;
+  int   clr=0;
   MY_CH ch[256];
-  
+    
   printf("<HTML>\n");
   printf("<HEAD>\n");
   printf("</HEAD>\n");
   printf("<BODY><PRE>\n");
   printf("Charset %s\n",cs->name);
+
+  printf("<TABLE>\n");
+  printf("<TR><TH>Code<TH>Uni<TH>Sort<TH>Ctype<TH>Ch<TH>Lo<TH>Up</TR>");
   
   for (i=0; i<256; i++)
   {
+    ch[i].cod=i;
     ch[i].srt=cs->sort_order[i];
     ch[i].uni=cs->tab_to_uni[i];
     ch[i].low=cs->tab_to_uni[cs->to_lower[i]];
@@ -65,12 +72,34 @@ static void print_cs(CHARSET_INFO *cs)
   }
   
   qsort(ch,256,sizeof(MY_CH),&chcmp);
-   
-  for (i=1; i<256; i++)
+  srt=ch[0].srt;
+  
+  for (i=0; i<256; i++)
   {
-    printf("%d %d &#%d; &#%d; &#%d;\n",ch[i].srt,ch[i].ctp,ch[i].uni,
-    				       ch[i].low,ch[i].upp);
+    clr = (srt!=ch[i].srt) ? !clr : clr;
+    
+    printf("<TR bgcolor=#%s>",clr ? "DDDDDD" : "EEEE99");
+    printf("<TD>%02X",ch[i].cod);
+    printf("<TD>%04X",ch[i].uni);
+    printf("<TD>%d",ch[i].srt);
+    
+    printf("<TD>%s%s%s%s%s%s%s%s",
+    		ch[i].ctp & _U ? "U" : "",
+    		ch[i].ctp & _L ? "L" : "",
+    		ch[i].ctp & _NMR ? "N" : "",
+    		ch[i].ctp & _SPC ? "S" : "",
+    		ch[i].ctp & _PNT ? "P" : "",
+    		ch[i].ctp & _CTR ? "C" : "",
+    		ch[i].ctp & _B ? "B" : "",
+    		ch[i].ctp & _X ? "X" : "");
+    
+    printf("<TD>&#%d;",ch[i].uni);
+    printf("<TD>&#%d;",ch[i].low);
+    printf("<TD>&#%d;",ch[i].upp);
+    printf("</TR>\n");
+    srt=ch[i].srt;
   }
+  printf("</TABLE>\n");
   printf("</PRE></BODY>\n");
   printf("</HTML>\n");
 }
-- 
cgit v1.2.1


From bf5b046e841121c4250bd668449df99302de31ea Mon Sep 17 00:00:00 2001
From: unknown <bar@bar.mysql.r18.ru>
Date: Thu, 15 Aug 2002 16:42:54 +0500
Subject: Some speed improvements

---
 mysys/hash.c       |  4 +++-
 mysys/mf_casecnv.c | 17 ++++++++++-------
 mysys/mf_soundex.c |  3 ++-
 3 files changed, 15 insertions(+), 9 deletions(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index 0cbd14607f6..7fb634a05b9 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -136,10 +136,12 @@ static uint calc_hashnr(CHARSET_INFO *cs __attribute__((unused)),
 static uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key,uint length)
 {
   register uint nr=1, nr2=4;
+  register uchar *map=cs->to_upper;
+  
   while (length--)
   {
     nr^= (((nr & 63)+nr2)*
-         ((uint) (uchar) my_toupper(cs, *key++)))+ (nr << 8);
+         ((uint) (uchar) map[(uchar)*key++])) + (nr << 8);
     nr2+=3;
   }
   return((uint) nr);
diff --git a/mysys/mf_casecnv.c b/mysys/mf_casecnv.c
index 510a9b08f76..631db18b1ed 100644
--- a/mysys/mf_casecnv.c
+++ b/mysys/mf_casecnv.c
@@ -33,8 +33,10 @@
 
 void case_sort(CHARSET_INFO *cs, my_string str, uint length)
 {
+  register uchar *map=cs->sort_order;
+  
   for ( ; length>0 ; length--, str++)
-    *str= (char) cs->sort_order[(uchar) *str];
+    *str= (char) map[(uchar) *str];
 } /* case_sort */
 
 
@@ -46,11 +48,11 @@ int my_sortcmp(CHARSET_INFO *cs, const char *s, const char *t, uint len)
   else
 #endif
   {
+    register uchar *map=cs->sort_order;
     while (len--)
     {
-      if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
-        return ((int) cs->sort_order[(uchar) s[-1]] -
-                (int) cs->sort_order[(uchar) t[-1]]);
+      if (map[(uchar) *s++] != map[(uchar) *t++])
+        return ((int) map[(uchar) s[-1]] - (int) map[(uchar) t[-1]]);
     }
     return 0;
   }
@@ -67,11 +69,12 @@ int my_sortncmp(CHARSET_INFO *cs,
 #endif
   {
     uint len= min(s_len,t_len);
+    register uchar *map=cs->sort_order;
+    
     while (len--)
     {
-      if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
-        return ((int) cs->sort_order[(uchar) s[-1]] -
-                (int) cs->sort_order[(uchar) t[-1]]);
+      if (map[(uchar) *s++] != map[(uchar) *t++])
+        return ((int) map[(uchar) s[-1]] - (int) map[(uchar) t[-1]]);
     }
     return (int) (s_len - t_len);
   }
diff --git a/mysys/mf_soundex.c b/mysys/mf_soundex.c
index 8ecd95137b0..459e304dfd7 100644
--- a/mysys/mf_soundex.c
+++ b/mysys/mf_soundex.c
@@ -44,13 +44,14 @@ void soundex(CHARSET_INFO * cs,register my_string out_pntr, my_string in_pntr,
 {
   char ch,last_ch;
   reg3 my_string end;
+  register uchar *map=cs->to_upper;
 
   if (remove_garbage)
   {
     while (*in_pntr && my_isspace(cs,*in_pntr))	/* Skipp pre-space */
       in_pntr++;
   }
-  *out_pntr++ = my_toupper(cs,*in_pntr);/* Copy first letter		 */
+  *out_pntr++ = map[(uchar)*in_pntr];	/* Copy first letter		 */
   last_ch = get_scode(cs,&in_pntr,0);	/* code of the first letter	 */
 					/* for the first 'double-letter  */
 					/* check.			 */
-- 
cgit v1.2.1


From 5a28c2caca888be932140d12f87c496398ad4220 Mon Sep 17 00:00:00 2001
From: unknown <monty@mashka.mysql.fi>
Date: Wed, 2 Oct 2002 13:33:08 +0300
Subject: Fixes and code cleanups after merge with 4.0.3 Warning handling and
 initial prepared statement handling (last not complete yet) Changed a lot of
 functions that returned 0/1 to my_bool type. GRANT handling now uses
 read/write locks instead of mutex Change basic net functions to use THD
 instead of NET (needed for 4.1 protocol) Use my_sprintf instead of sprintf()
 + strlen() Added alloc_query() to be able to chare query initialization code
 with prepared statements. Cleanup handling of SHOW COUNT(*) WARNINGS and
 SELECT LAST_INSERT_ID()

Note that the following test fails (will be fixed ASAP):
sub_select, union, rpl_rotate_logs and rpl_mystery22


BitKeeper/deleted/.del-README~3449730baf983117:
  Delete: mysql-test/t/README
BitKeeper/deleted/.del-sql_error.cc~2f1caca8d2485dbe:
  Delete: libmysqld/sql_error.cc
BitKeeper/deleted/.del-sql_prepare.cc~f703729793935ed6:
  Delete: libmysqld/sql_prepare.cc
Docs/manual.texi:
  Updated variable list
client/mysql.cc:
  Show warning count to user.
client/mysqltest.c:
  Add warnings to test results
configure.in:
  New shared library version number
include/errmsg.h:
  Indentation cleanup
include/mysql.h:
  Removed MYSQL_ERROR
  Indentaion cleanups
include/mysql_com.h:
  Changed functions to returns true/false to my_bool.
include/mysqld_error.h:
  New error messages
isam/pack_isam.c:
  Indentation change
libmysql/Makefile.am:
  Fix of wrong merge
libmysql/Makefile.shared:
  Indentation cleanup
libmysql/errmsg.c:
  Removed not used errors
libmysql/libmysql.c:
  Change functions to return 1 on error (not -1)
  Change type of functions that returns 0/1 to my_bool
  Lot of code optimizations.
  Lot of changes for prepared statements. This now handles sending of binary data to server.
  Receving of binary data is not yet done (will have to wait until server code for this is ready)
  mysql_warning_count and mysql_warnings() implemented.
libmysql/libmysql.def:
  Added mysql_warnings and mysql_warning_count
libmysql/manager.c:
  Fixed wrong testing of result from my_connect()
libmysqld/lib_sql.cc:
  Removed global variable THR_NET
  Change basic net functions to use THD instead of NET
  GRANT handling now uses read/write locks instead of mutex
libmysqld/libmysqld.c:
  Changed functions to be my_bool
myisam/ft_boolean_search.c:
  Trivial code cleanup
myisam/ft_stopwords.c:
  Trivial code cleanup
myisam/mi_check.c:
  Update to 4.1 structures
myisam/myisampack.c:
  Trivial code cleanup
myisam/rt_key.c:
  Code cleanup
myisam/rt_test.c:
  Code cleanup
  Removed compiler warnings
myisam/sp_key.c:
  Indentation changes
myisam/sp_test.c:
  Removed compiler warnings
mysql-test/README:
  Updated to reflect the new --external flag.
mysql-test/mysql-test-run.sh:
  --local (start new server) is now default.
  Use --external to test against external server.
mysql-test/r/rollback.result:
  Updated for 4.1 warnings
mysql-test/r/rpl_log.result:
  Update for 4.1
mysql-test/t/rollback.test:
  Updated for 4.1 warnings
mysql-test/t/rpl_log_pos.test:
  Portability fix
mysys/hash.c:
  Indentation change
mysys/my_error.c:
  Indentation change
mysys/tree.c:
  Updated file description
sql/field.cc:
  Fixed bugs introduced by merge
  Use my_sprintf instead of sprintf() + strlen()
sql/field.h:
  Add CHARSET_INFO to field structure
sql/gstream.h:
  Indentation changes.
  Added GPL copyright header
sql/ha_innodb.cc:
  Updated parameters for net functions.
sql/item.cc:
  Updates of Item_param
  Indentation changes
sql/item.h:
  Removed size_of() function from item.
sql/item_func.cc:
  Update function usage for 4.1
  Added get_system_var()
sql/item_func.h:
  Indentation change
sql/item_strfunc.cc:
  Removed not needed inclusion of gstream.h
  Update to use system variables (from 4.0)
sql/item_sum.h:
  Removed size_of() functions from item.
sql/item_timefunc.cc:
  Change sprintf() + strlen() -> my_sprintf()
  Added length parameter to ->append()
sql/item_timefunc.h:
  Removed size_of() functions from item.
sql/item_uniq.h:
  Removed size_of() functions from item.
sql/lex.h:
  Removed SQL_ERROR_COUNT variable
sql/log.cc:
  Change sprintf() + strlen() -> my_sprintf()
sql/log_event.cc:
  Change sprintf() + strlen() -> my_sprintf()
sql/mini_client.cc:
  Added check that one always specifies a length to mc_mysql_query()
sql/mysql_priv.h:
  New prototypes
  Change of NET -> THD parameter for net functions.
sql/mysqld.cc:
  New startup options:  'max_prepared_statements', 'max_error_count'
  Updated usage of net functions.
sql/net_pkg.cc:
  Change basic net functions to use THD instead of NET
  (needed to be able to handle 4.0 and 4.1 protocols)
  Lots of function comments
sql/net_serv.cc:
  Change int return values -> my_bool
  Updated net_write_command() to take an extra header block to be added to the packet.
  (This made the prepared statement code much nicer and more efficient)
sql/repl_failsafe.cc:
  Update net functions to use THD instead of NET
sql/set_var.cc:
  Added @@error_count and @@warning_count variables.
  Updated to 4.1 function usage
sql/set_var.h:
  Added @@error_count and @@warning_count variables.
sql/share/czech/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/english/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/greek/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/hungarian/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/japanese/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/korean/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/norwegian-ny/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/norwegian/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/polish/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/romanian/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/slovak/errmsg.txt:
  Removed Warning: from warning error messages.
sql/share/swedish/errmsg.txt:
  Removed Warning: from warning error messages.
sql/slave.cc:
  Change basic net functions to use THD instead of NET
  skip_load_data_file recoded to fit new client/server protocol
sql/spatial.h:
  Added copyright header
  Indentation cleanups
sql/sql_acl.cc:
  Change basic net functions to use THD instead of NET
  GRANT handling now uses read/write locks instead of mutex
sql/sql_analyse.cc:
  Change basic net functions to use THD instead of NET
  sprintf() + strlen() -> my_sprintf()
sql/sql_base.cc:
  More DBUG statements
sql/sql_class.cc:
  Change basic net functions to use THD instead of NET
  warning and prepared statement handling
sql/sql_class.h:
  Change basic net functions to use THD instead of NET
  warning and prepared statement handling
sql/sql_db.cc:
  Code cleanup & optimization.
sql/sql_delete.cc:
  Change basic net functions to use THD instead of NET
sql/sql_derived.cc:
  Change basic net functions to use THD instead of NET
sql/sql_do.cc:
  Change basic net functions to use THD instead of NET
sql/sql_error.cc:
  Big rewrite of error handling.
sql/sql_handler.cc:
  Change basic net functions to use THD instead of NET
sql/sql_insert.cc:
  Change basic net functions to use THD instead of NET
sql/sql_lex.cc:
  Change basic net functions to use THD instead of NET
sql/sql_lex.h:
  Added param_count to st_select_lex_node
sql/sql_list.h:
  Removed not needed error list.
sql/sql_load.cc:
  Change basic net functions to use THD instead of NET
sql/sql_parse.cc:
  Change basic net functions to use THD instead of NET
  Added alloc_query() to be able to chare query initialization code with
  prepared statements.
  Update of warning handling.
  Added create_select_for_variable() (for SHOW COUNT(*) WARNINGS)
sql/sql_prepare.cc:
  Initial prepared statement handling
sql/sql_rename.cc:
  Change basic net functions to use THD instead of NET
sql/sql_repl.cc:
  Change basic net functions to use THD instead of NET
sql/sql_select.cc:
  Small code cleanups
  Added missing initialization of error that caused some queries that returned an empty result set to fail
sql/sql_select.h:
  Ensure that JOIN.error is properly initialized
sql/sql_show.cc:
  Change basic net functions to use THD instead of NET
  A lot of optimization
sql/sql_table.cc:
  Change basic net functions to use THD instead of NET
  Indentaion cleanup
sql/sql_udf.cc:
  Change basic net functions to use THD instead of NET
sql/sql_union.cc:
  Change basic net functions to use THD instead of NET
sql/sql_update.cc:
  Change basic net functions to use THD instead of NET
sql/sql_yacc.yy:
  Change basic net functions to use THD instead of NET
  Cleanup handling of SHOW COUNT(*) WARNINGS and SELECT LAST_INSERT_ID()
sql/structs.h:
  Moved structures to files where they was used
sql/table.cc:
  Don't accept empty database names
sql/uniques.cc:
  Indentation cleanup
sql/unireg.cc:
  Change basic net functions to use THD instead of NET
sql/unireg.h:
  Added defaults for warnings and prepared statements
strings/ctype-simple.c:
  optimization
tests/client_test.c:
  Fixed wrong paramaters to printf()
---
 mysys/hash.c     |  7 ++++---
 mysys/my_error.c |  2 +-
 mysys/tree.c     | 25 ++++++++++++++++---------
 3 files changed, 21 insertions(+), 13 deletions(-)

(limited to 'mysys')

diff --git a/mysys/hash.c b/mysys/hash.c
index 7fb634a05b9..43e6981f79d 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -35,11 +35,12 @@ static uint calc_hashnr(CHARSET_INFO *cs,const byte *key,uint length);
 static uint calc_hashnr_caseup(CHARSET_INFO *cs, const byte *key,uint length);
 static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
 
+
 my_bool
 _hash_init(HASH *hash,CHARSET_INFO *charset,
-		  uint size,uint key_offset,uint key_length,
-		  hash_get_key get_key,
-		  void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
+	   uint size,uint key_offset,uint key_length,
+	   hash_get_key get_key,
+	   void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
 {
   DBUG_ENTER("hash_init");
   DBUG_PRINT("enter",("hash: %lx  size: %d",hash,size));
diff --git a/mysys/my_error.c b/mysys/my_error.c
index eaa126a31c1..cd41589f366 100644
--- a/mysys/my_error.c
+++ b/mysys/my_error.c
@@ -120,7 +120,7 @@ int my_error(int nr,myf MyFlags, ...)
       ...	variable list
 */
 
-int my_printf_error (uint error, const char *format, myf MyFlags, ...)
+int my_printf_error(uint error, const char *format, myf MyFlags, ...)
 {
   va_list args;
   char ebuff[ERRMSGSIZE+20];
diff --git a/mysys/tree.c b/mysys/tree.c
index 489262fcdc7..f72a4961312 100644
--- a/mysys/tree.c
+++ b/mysys/tree.c
@@ -17,26 +17,33 @@
 /*
   Code for handling red-black (balanced) binary trees.
   key in tree is allocated accrding to following:
-  1) If free_element function is given to init_tree or size < 0 then tree
-     will not allocate keys and only a pointer to each key is saved in tree.
-     key_sizes must be 0 to init and search.
+
+  1) If size < 0 then tree will not allocate keys and only a pointer to
+     each key is saved in tree.
+     compare and search functions uses and returns key-pointer
+
+  2) If size == 0 then there are two options:
+       - key_size != 0 to tree_insert: The key will be stored in the tree.
+       - key_size == 0 to tree_insert:  A pointer to the key is stored.
      compare and search functions uses and returns key-pointer.
-  2) if key_size is given to init_tree then each node will continue the
+
+  3) if key_size is given to init_tree then each node will continue the
      key and calls to insert_key may increase length of key.
      if key_size > sizeof(pointer) and key_size is a multiple of 8 (double
      allign) then key will be put on a 8 alligned adress. Else
      the key will be on adress (element+1). This is transparent for user
      compare and search functions uses a pointer to given key-argument.
-  3) If init_tree - keysize is 0 then key_size must be given to tree_insert
-     and tree_insert will alloc space for key.
-     compare and search functions uses a pointer to given key-argument.
+
+  - If you use a free function for tree-elements and you are freeing
+    the element itself, you should use key_size = 0 to init_tree and
+    tree_search
 
   The actual key in TREE_ELEMENT is saved as a pointer or after the
   TREE_ELEMENT struct.
   If one uses only pointers in tree one can use tree_set_pointer() to
   change address of data.
-  Copyright Monty Program KB.
-  By monty.
+
+  Implemented by monty.
 */
 
 #include "mysys_priv.h"
-- 
cgit v1.2.1