Added all changes from old 4.0 version:

PSTACK, libmysqld and MySQL filesystem
UPDATE ... ORDER BY
DELETE ... ORDER BY
New faster fulltext handling
Faster compressed keys



Makefile.am:
  Added support for pstack and libmysqld_dir
acconfig.h:
  MySQL filesystem and PSTACK
acinclude.m4:
  MySQL File system
client/mysql.cc:
  Support for --xml
configure.in:
  Pstack, MySQL FS and libmysqld_dir
include/ft_global.h:
  Faster fulltext
include/my_pthread.h:
  Made c++ safe
include/myisam.h:
  Update for faster fulltext
include/mysql_com.h:
  new my_net_read()
include/violite.h:
  libmysqld
libmysql/net.c:
  New protocol that supports big packets
myisam/Makefile.am:
  Faster fulltext
myisam/ft_parser.c:
  Faster fulltext
myisam/ft_search.c:
  Faster fulltext
myisam/ft_update.c:
  Faster fulltext
myisam/ftdefs.h:
  Faster fulltext
myisam/mi_check.c:
  Faster fulltext
myisam/mi_open.c:
  Faster compressed keys
myisam/mi_search.c:
  Faster compressed keys
myisam/mi_update.c:
  Faster compressed keys
myisam/myisamdef.h:
  Faster compressed keys
myisam/sort.c:
  Faster compressed keys
mysql-test/mysql-test-run.sh:
  --skip-innobase and --skip-bdb
sql/ChangeLog:
  Changelog
sql/Makefile.am:
  PSTACK
sql/mysql_priv.h:
  New ORDER BY options and libmysqld
sql/mysqld.cc:
  PSTACK
sql/net_serv.cc:
  New protocol that supports big packets
sql/share/estonian/errmsg.txt:
  New error messages
sql/sql_base.cc:
  Better list_open_tabels
sql/sql_delete.cc:
  ORDER BY for delete
sql/sql_lex.cc:
  Added language convertation of all strings
sql/sql_parse.cc:
  Changes for libmysqld
  Use new ORDER BY options
sql/sql_show.cc:
  Character set convertations
  Use new list_open_tables function.
sql/sql_update.cc:
  UPDATE ... ORDER BY
sql/sql_yacc.yy:
  Clean up symbol definitions
  DELETE .. ORDER BY
  UPDATE .. ORDER BY
sql/table.h:
  new OPEN_TABLE_LIST structure
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

1 files changed, 720 insertions, 518 deletions

diff --git a/myisam/mi_search.c b/myisam/mi_search.c
index 7888e73b235..dee1b6e847a 100644
--- a/myisam/mi_search.c
+++ b/myisam/mi_search.c
@@ -22,26 +22,26 @@
 #define CMP(a,b) (a<b ? -1 : a == b ? 0 : 1)
 
 static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
-				uchar *key, uchar *keypos,
-				uint *return_key_length);
+                                uchar *key, uchar *keypos,
+                                uint *return_key_length);
 
-	/* Check index */
+        /* Check index */
 
 int _mi_check_index(MI_INFO *info, int inx)
 {
-  if (inx == -1)			/* Use last index */
+  if (inx == -1)                        /* Use last index */
     inx=info->lastinx;
   if (inx < 0 || ! (((ulonglong) 1 << inx) & info->s->state.key_map))
   {
     my_errno=HA_ERR_WRONG_INDEX;
     return -1;
   }
-  if (info->lastinx != inx)		/* Index changed */
+  if (info->lastinx != inx)             /* Index changed */
   {
     info->lastinx = inx;
     info->page_changed=1;
     info->update= ((info->update & (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED)) |
-		   HA_STATE_NEXT_FOUND | HA_STATE_PREV_FOUND);
+                   HA_STATE_NEXT_FOUND | HA_STATE_PREV_FOUND);
   }
   if (info->opt_flag & WRITE_CACHE_USED && flush_io_cache(&info->rec_cache))
     return(-1);
@@ -49,15 +49,15 @@ int _mi_check_index(MI_INFO *info, int inx)
 } /* mi_check_index */
 
 
-	/*
-	** Search after row by a key
-	** Position to row is stored in info->lastpos
-	** Return: -1 if not found
-	**	    1 if one should continue search on higher level
-	*/
+        /*
+        ** Search after row by a key
+        ** Position to row is stored in info->lastpos
+        ** Return: -1 if not found
+        **          1 if one should continue search on higher level
+        */
 
 int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
-	       uchar *key, uint key_len, uint nextflag, register my_off_t pos)
+               uchar *key, uint key_len, uint nextflag, register my_off_t pos)
 {
   my_bool last_key;
   int error,flag;
@@ -66,25 +66,25 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   uchar lastkey[MI_MAX_KEY_BUFF],*buff;
   DBUG_ENTER("_mi_search");
   DBUG_PRINT("enter",("pos: %ld  nextflag: %d  lastpos: %ld",
-		      pos,nextflag,info->lastpos));
+                      pos,nextflag,info->lastpos));
   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,key_len););
 
   if (pos == HA_OFFSET_ERROR)
   {
-    my_errno=HA_ERR_KEY_NOT_FOUND;			/* Didn't find key */
+    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
     info->lastpos= HA_OFFSET_ERROR;
     if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
-      DBUG_RETURN(-1);				/* Not found ; return error */
-    DBUG_RETURN(1);				/* Search at upper levels */
+      DBUG_RETURN(-1);                          /* Not found ; return error */
+    DBUG_RETURN(1);                             /* Search at upper levels */
   }
 
   if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
-			       test(!(nextflag & SEARCH_SAVE_BUFF)))))
+                               test(!(nextflag & SEARCH_SAVE_BUFF)))))
     goto err;
   DBUG_DUMP("page",(byte*) buff,mi_getint(buff));
 
   flag=(*keyinfo->bin_search)(info,keyinfo,buff,key,key_len,nextflag,
-			      &keypos,lastkey, &last_key);
+                              &keypos,lastkey, &last_key);
   if (flag == MI_FOUND_WRONG_KEY)
     DBUG_RETURN(-1);
   nod_flag=mi_test_if_nod(buff);
@@ -93,35 +93,35 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   if (flag)
   {
     if ((error=_mi_search(info,keyinfo,key,key_len,nextflag,
-			  _mi_kpos(nod_flag,keypos))) <= 0)
+                          _mi_kpos(nod_flag,keypos))) <= 0)
       DBUG_RETURN(error);
 
     if (flag >0)
     {
       if (nextflag & (SEARCH_SMALLER | SEARCH_LAST) &&
-	  keypos == buff+2+nod_flag)
-	DBUG_RETURN(1);					/* Bigger than key */
+          keypos == buff+2+nod_flag)
+        DBUG_RETURN(1);                                 /* Bigger than key */
     }
     else if (nextflag & SEARCH_BIGGER && keypos >= maxpos)
-      DBUG_RETURN(1);					/* Smaller than key */
+      DBUG_RETURN(1);                                   /* Smaller than key */
   }
   else
   {
     if (nextflag & SEARCH_FIND && (!(keyinfo->flag & HA_NOSAME)
-				   || key_len) && nod_flag)
+                                   || key_len) && nod_flag)
     {
       if ((error=_mi_search(info,keyinfo,key,key_len,SEARCH_FIND,
-			    _mi_kpos(nod_flag,keypos))) >= 0 ||
-	  my_errno != HA_ERR_KEY_NOT_FOUND)
-	DBUG_RETURN(error);
-      info->last_keypage= HA_OFFSET_ERROR;		/* Buffer not in memory */
+                            _mi_kpos(nod_flag,keypos))) >= 0 ||
+          my_errno != HA_ERR_KEY_NOT_FOUND)
+        DBUG_RETURN(error);
+      info->last_keypage= HA_OFFSET_ERROR;              /* Buffer not in memory */
     }
   }
   if (pos != info->last_keypage)
   {
     uchar *old_buff=buff;
     if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
-				 test(!(nextflag & SEARCH_SAVE_BUFF)))))
+                                 test(!(nextflag & SEARCH_SAVE_BUFF)))))
       goto err;
     keypos=buff+(keypos-old_buff);
     maxpos=buff+(maxpos-old_buff);
@@ -131,13 +131,13 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   {
     uint not_used;
     if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
-			 &info->lastkey_length))
+                         &info->lastkey_length))
       goto err;
     if ((nextflag & SEARCH_LAST) &&
-	_mi_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
-		    &not_used))
+        _mi_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
+                    &not_used))
     {
-      my_errno=HA_ERR_KEY_NOT_FOUND;			/* Didn't find key */
+      my_errno=HA_ERR_KEY_NOT_FOUND;                    /* Didn't find key */
       goto err;
     }
   }
@@ -156,7 +156,7 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   info->int_keytree_version=keyinfo->version;
   info->last_search_keypage=info->last_keypage;
   info->page_changed=0;
-  info->buff_used= (info->buff != buff);	/* If we have to reread buff */
+  info->buff_used= (info->buff != buff);        /* If we have to reread buff */
 
   DBUG_PRINT("exit",("found key at %ld",info->lastpos));
   DBUG_RETURN(0);
@@ -168,14 +168,14 @@ err:
 } /* _mi_search */
 
 
-	/* Search after key in page-block */
-	/* If packed key puts smaller or identical key in buff */
-	/* ret_pos point to where find or bigger key starts */
-	/* ARGSUSED */
+        /* Search after key in page-block */
+        /* If packed key puts smaller or identical key in buff */
+        /* ret_pos point to where find or bigger key starts */
+        /* ARGSUSED */
 
 int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
-		   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
-		   uchar *buff __attribute__((unused)), my_bool *last_key)
+                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
+                   uchar *buff __attribute__((unused)), my_bool *last_key)
 {
   reg4 int start,mid,end,save_end;
   int flag;
@@ -193,17 +193,17 @@ int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
   {
     mid= (start+end)/2;
     if ((flag=_mi_key_cmp(keyinfo->seg,page+(uint) mid*totlength,key,key_len,
-			  comp_flag,&not_used))
-	>= 0)
+                          comp_flag,&not_used))
+        >= 0)
       end=mid;
     else
       start=mid+1;
   }
   if (mid != start)
     flag=_mi_key_cmp(keyinfo->seg,page+(uint) start*totlength,key,key_len,
-		     comp_flag,&not_used);
+                     comp_flag,&not_used);
   if (flag < 0)
-    start++;			/* point at next, bigger key */
+    start++;                    /* point at next, bigger key */
   *ret_pos=page+(uint) start*totlength;
   *last_key= end == save_end;
   DBUG_PRINT("exit",("flag: %d  keypos: %d",flag,start));
@@ -211,13 +211,13 @@ int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 } /* _mi_bin_search */
 
 
-	/* Used instead of _mi_bin_search() when key is packed */
-	/* Puts smaller or identical key in buff */
-	/* Key is searched sequentially */
+        /* Used instead of _mi_bin_search() when key is packed */
+        /* Puts smaller or identical key in buff */
+        /* Key is searched sequentially */
 
 int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
-		   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
-		   uchar *buff, my_bool *last_key)
+                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
+                   uchar *buff, my_bool *last_key)
 {
   int flag;
   uint nod_flag,length,not_used;
@@ -229,7 +229,7 @@ int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
   nod_flag=mi_test_if_nod(page);
   page+=2+nod_flag;
   *ret_pos=page;
-  t_buff[0]=0;					/* Avoid bugs */
+  t_buff[0]=0;                                  /* Avoid bugs */
   while (page < end)
   {
     length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,t_buff);
@@ -237,11 +237,11 @@ int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
     {
       my_errno=HA_ERR_CRASHED;
       DBUG_PRINT("error",("Found wrong key:  length: %d  page: %lx  end: %lx",
-			  length,page,end));
+                          length,page,end));
       DBUG_RETURN(MI_FOUND_WRONG_KEY);
     }
     if ((flag=_mi_key_cmp(keyinfo->seg,t_buff,key,key_len,comp_flag,
-			  &not_used)) >= 0)
+                          &not_used)) >= 0)
       break;
 #ifdef EXTRA_DEBUG
     DBUG_PRINT("loop",("page: %lx  key: '%s'  flag: %d",page,t_buff,flag));
@@ -250,14 +250,216 @@ int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
     *ret_pos=page;
   }
   if (flag == 0)
-    memcpy(buff,t_buff,length);			/* Result is first key */
+    memcpy(buff,t_buff,length);                 /* Result is first key */
   *last_key= page == end;
   DBUG_PRINT("exit",("flag: %d  ret_pos: %lx",flag,*ret_pos));
   DBUG_RETURN(flag);
 } /* _mi_seq_search */
 
+int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
+                      uchar *key, uint key_len, uint nextflag, uchar **ret_pos,
+                      uchar *buff, my_bool *last_key)
+{
+  /* my_flag is raw comparison result to be changed according to
+     SEARCH_NO_FIND,SEARCH_LAST and HA_REVERSE_SORT flags.
+     flag is the value returned by _mi_key_cmp and as treated as final */
+  int flag=0, my_flag=-1;
+  uint nod_flag, length, len, matched, cmplen, kseg_len, key_len_left;
+  uint prefix_len,suffix_len;
+  int key_len_skip, seg_len_pack;
+  uchar *end, *kseg, *vseg;
+  uchar *sort_order=keyinfo->seg->charset->sort_order;
+  uchar tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
+  uchar *saved_from, *saved_to, *saved_vseg;
+  uint   saved_length=0, saved_prefix_len=0;
+  DBUG_ENTER("_mi_prefix_search");
+
+  t_buff[0]=0;                                  /* Avoid bugs */
+  if (!(nextflag & (SEARCH_FIND | SEARCH_NO_FIND | SEARCH_LAST)))
+    key_len=USE_WHOLE_KEY;
+  end= page+mi_getint(page);
+  nod_flag=mi_test_if_nod(page);
+  page+=2+nod_flag;
+  *ret_pos=page;
+  kseg=key;
+  {
+    uint lenght_pack;
+    get_key_pack_length(kseg_len,lenght_pack,kseg);
+    key_len_skip=lenght_pack+kseg_len;
+    key_len_left=key_len-key_len_skip;
+    cmplen=(key_len_left>=0) ? kseg_len : key_len-lenght_pack;
+  }
+
+/*
+  Keys are compressed the following way:
+
+  If the max length of first key segment <= 127 characters the prefix is
+  1 byte else it's 2 byte
+
+  prefix         The high bit is set if this is a prefix for the prev key
+  length         Packed length if the previous was a prefix byte
+  [length]       Length character of data
+  next-key-seg   Next key segments
+*/
+
+  matched=0;  /* how many char's from prefix were alredy matched */
+  len=0;      /* length of previous key unpacked */
+
+  while (page < end)
+  {
+    uint packed= *page & 128;
+    
+    vseg=page;
+    if (keyinfo->seg->length >= 127)
+    {
+      suffix_len=mi_uint2korr(vseg) & 32767;
+      vseg+=2;
+    }
+    else
+      suffix_len= *vseg++ & 127;
+
+    if (packed)
+    {
+      if (suffix_len == 0)                      /* Same key */
+        prefix_len=len;
+      else
+      {
+        prefix_len=suffix_len;       
+        get_key_length(suffix_len,vseg);
+      }
+    }
+    else
+      prefix_len=0;
+
+    len=prefix_len+suffix_len;
+    seg_len_pack=get_pack_length(len);
+    t_buff=tt_buff+3-seg_len_pack;
+    store_key_length(t_buff,len);
 
-	/* Get pos to a key_block */
+    if (prefix_len > saved_prefix_len)
+      memcpy(t_buff+seg_len_pack+saved_prefix_len,saved_vseg,
+             prefix_len-saved_prefix_len);
+    saved_vseg=vseg;
+    saved_prefix_len=prefix_len;
+
+    {
+      uchar *from=vseg+suffix_len;
+      MI_KEYSEG *keyseg;
+      uint l;
+
+      for (keyseg=keyinfo->seg+1 ; keyseg->type ; keyseg++ )
+      {
+        
+        if (keyseg->flag & HA_NULL_PART)
+        {
+          if (!(*from++))
+            continue;
+        }
+        if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
+        {
+          get_key_length(l,from);
+        }
+        else
+          l=keyseg->length;
+
+        from+=l;
+      }
+      from+=keyseg->length;
+      page=from+nod_flag;
+      length=from-vseg;
+    }
+
+    if (page > end)
+    {
+      my_errno=HA_ERR_CRASHED;
+      DBUG_PRINT("error",("Found wrong key:  length: %d  page: %lx  end: %lx",
+                          length,page,end));
+      DBUG_RETURN(MI_FOUND_WRONG_KEY);
+    }
+
+    if (matched >= prefix_len)
+    {
+      /* We have to compare. But we can still skip part of the key */
+      uint  left;
+      uchar *k=kseg+prefix_len;
+
+      left=(len>cmplen) ? cmplen-prefix_len : suffix_len;
+
+      matched=prefix_len+left;
+
+      for(my_flag=0;left;left--)
+        if ((my_flag= (int) sort_order[*vseg++] - (int) sort_order[*k++]))
+          break;
+
+      if (my_flag>0)      /* mismatch */
+        break;
+      else if (my_flag==0) /* match */
+      { /*
+        **  len cmplen seg_left_len more_segs
+        **     <                               matched=len; continue search
+        **     >      =                        prefix ? found : (matched=len; continue search)
+        **     >      <                 -      ok, found
+        **     =      <                 -      ok, found
+        **     =      =                 -      ok, found
+        **     =      =                 +      next seg
+        */
+        if (len < cmplen)
+        {
+          my_flag=-1;
+        }
+        else if (len > cmplen)
+        {
+          if(my_flag = !(nextflag & SEARCH_PREFIX) && key_len_left>0)
+            break;
+          goto fix_flag;
+        }
+        else if (key_len_left>0)
+        {
+          uint not_used;
+          if ((flag = _mi_key_cmp(keyinfo->seg+1,vseg,
+                                  k,key_len_left,nextflag,&not_used)) >= 0)
+            break;
+        }
+        else
+        {
+          /* at this line flag==-1 if the following lines were already
+             visited and 0 otherwise,  i.e. flag <=0 here always !!! */
+  fix_flag:
+          if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST))
+            flag=(nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
+          if (flag>=0) break;
+        }
+      }
+      matched-=left;
+    }
+    /* else (matched < prefix_len) ---> do nothing. */
+
+    memcpy(buff,t_buff,saved_length=seg_len_pack+prefix_len);
+    saved_to=buff+saved_length;
+    saved_from=saved_vseg;
+    saved_length=length;
+    *ret_pos=page;
+  }
+  if (my_flag)
+    flag=(keyinfo->seg->flag & HA_REVERSE_SORT) ? -my_flag : my_flag;
+  if (flag == 0)
+  {
+    memcpy(buff,t_buff,saved_length=seg_len_pack+prefix_len);
+    saved_to=buff+saved_length;
+    saved_from=saved_vseg;
+    saved_length=length;
+  }
+  if (saved_length)
+    memcpy(saved_to,saved_from,saved_length);
+
+  *last_key= page == end;
+
+  DBUG_PRINT("exit",("flag: %d  ret_pos: %lx",flag,*ret_pos));
+  DBUG_RETURN(flag);
+} /* _mi_prefix_search */
+
+
+        /* Get pos to a key_block */
 
 my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
 {
@@ -286,14 +488,14 @@ my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
     return (my_off_t) (mi_uint2korr(after_key)*MI_KEY_BLOCK_LENGTH);
   case 1:
     return (uint) (*after_key)*MI_KEY_BLOCK_LENGTH;
-  case 0:					/* At leaf page */
-  default:					/* Impossible */
+  case 0:                                       /* At leaf page */
+  default:                                      /* Impossible */
     return(HA_OFFSET_ERROR);
   }
 } /* _kpos */
 
 
-	/* Save pos to a key_block */
+        /* Save pos to a key_block */
 
 void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
 {
@@ -315,12 +517,12 @@ void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
   case 3: mi_int3store(buff,pos); break;
   case 2: mi_int2store(buff,(uint) pos); break;
   case 1: buff[0]= (uchar) pos; break;
-  default: abort();				/* impossible */
+  default: abort();                             /* impossible */
   }
 } /* _mi_kpointer */
 
 
-	/* Calc pos to a data-record from a key */
+        /* Calc pos to a data-record from a key */
 
 
 my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
@@ -335,19 +537,19 @@ my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
   case 5:  pos= (my_off_t) mi_uint5korr(after_key);  break;
 #else
   case 8:  pos= (my_off_t) mi_uint4korr(after_key+4);   break;
-  case 7:  pos= (my_off_t) mi_uint4korr(after_key+3);	break;
-  case 6:  pos= (my_off_t) mi_uint4korr(after_key+2);	break;
-  case 5:  pos= (my_off_t) mi_uint4korr(after_key+1);	break;
+  case 7:  pos= (my_off_t) mi_uint4korr(after_key+3);   break;
+  case 6:  pos= (my_off_t) mi_uint4korr(after_key+2);   break;
+  case 5:  pos= (my_off_t) mi_uint4korr(after_key+1);   break;
 #endif
   case 4:  pos= (my_off_t) mi_uint4korr(after_key);  break;
   case 3:  pos= (my_off_t) mi_uint3korr(after_key);  break;
   case 2:  pos= (my_off_t) mi_uint2korr(after_key);  break;
   default:
-    pos=0L;					/* Shut compiler up */
+    pos=0L;                                     /* Shut compiler up */
   }
   return (info->s->options &
-	  (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
-	    pos*info->s->base.pack_reclength;
+          (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
+            pos*info->s->base.pack_reclength;
 }
 
 
@@ -361,22 +563,22 @@ my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
   case 8:
     pos= (my_off_t) mi_uint8korr(ptr);
     if (pos == HA_OFFSET_ERROR)
-      return HA_OFFSET_ERROR;			/* end of list */
+      return HA_OFFSET_ERROR;                   /* end of list */
     break;
   case 7:
     pos= (my_off_t) mi_uint7korr(ptr);
     if (pos == (((my_off_t) 1) << 56) -1)
-      return HA_OFFSET_ERROR;			/* end of list */
+      return HA_OFFSET_ERROR;                   /* end of list */
     break;
   case 6:
     pos= (my_off_t) mi_uint6korr(ptr);
     if (pos == (((my_off_t) 1) << 48) -1)
-      return HA_OFFSET_ERROR;			/* end of list */
+      return HA_OFFSET_ERROR;                   /* end of list */
     break;
   case 5:
     pos= (my_off_t) mi_uint5korr(ptr);
     if (pos == (((my_off_t) 1) << 40) -1)
-      return HA_OFFSET_ERROR;			/* end of list */
+      return HA_OFFSET_ERROR;                   /* end of list */
     break;
 #else
   case 8:
@@ -401,20 +603,20 @@ my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
     if (pos == (my_off_t) (1 << 16) -1)
       return HA_OFFSET_ERROR;
     break;
-  default: abort();				/* Impossible */
+  default: abort();                             /* Impossible */
   }
   return ((s->options &
-	  (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
-	  pos*s->base.pack_reclength);
+          (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
+          pos*s->base.pack_reclength);
 }
 
 
-	/* save position to record */
+        /* save position to record */
 
 void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
 {
   if (!(info->s->options &
-	(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
+        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
       pos != HA_OFFSET_ERROR)
     pos/=info->s->base.pack_reclength;
 
@@ -437,13 +639,13 @@ void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
   case 4: mi_int4store(buff,pos); break;
   case 3: mi_int3store(buff,pos); break;
   case 2: mi_int2store(buff,(uint) pos); break;
-  default: abort();				/* Impossible */
+  default: abort();                             /* Impossible */
   }
 } /* _mi_dpointer */
 
 
 int _mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
-		     uchar *b, uint b_length, my_bool part_key)
+                     uchar *b, uint b_length, my_bool part_key)
 {
   uint length= min(a_length,b_length);
   uchar *end= a+ length;
@@ -470,7 +672,7 @@ int _mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
 
 
 static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
-		       my_bool part_key)
+                       my_bool part_key)
 {
   uint length= min(a_length,b_length);
   uchar *end= a+ length;
@@ -485,19 +687,19 @@ static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
 }
 
 
-	/*
-	** Compare two keys with is bigger
-	** Returns <0, 0, >0 acording to with 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 with is bigger
+        ** Returns <0, 0, >0 acording to with is bigger
+        ** Key_length specifies length of key to use.  Number-keys can't
+        ** be splited
+        ** If flag <> SEARCH_FIND compare also position
+        */
 
 #define FCMP(A,B) ((int) (A) - (int) (B))
 
 int _mi_key_cmp(register MI_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;
@@ -522,106 +724,106 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       key_length--;
       if (*a != *b)
       {
-	flag = (int) *a - (int) *b;
-	return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        flag = (int) *a - (int) *b;
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       }
       b++;
-      if (!*a++)				/* If key was NULL */
+      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 */
+        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 */
+    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;
+        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);
-	if ((flag=_mi_compare_text(keyseg->charset,a,length,b,length,
-				   (my_bool) ((nextflag & SEARCH_PREFIX) &&
-					      next_key_length <= 0))))
-	  return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
-	a=end;
-	b+=length;
+        uint length=(uint) (end-a);
+        if ((flag=_mi_compare_text(keyseg->charset,a,length,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;
+        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;
+        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;
+        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;
+        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:
@@ -629,7 +831,7 @@ int _mi_key_cmp(register MI_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)))
-	return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a= end;
       b++;
       break;
@@ -638,26 +840,26 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        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;
+        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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(long int); */
       break;
@@ -665,7 +867,7 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(long int); */
       break;
@@ -673,7 +875,7 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 3;
       break;
@@ -681,7 +883,7 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 3;
       break;
@@ -689,7 +891,7 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 4; /* sizeof(float); */
       break;
@@ -697,65 +899,65 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 8;  /* sizeof(double); */
       break;
-    case HA_KEYTYPE_NUM:				/* Numeric key */
+    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 */
+        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;
+        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--) ;
+        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;
+        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;
+        return 1;
       while (alength && (*a == '+' || *a == '0'))
       {
-	a++; alength--;
+        a++; alength--;
       }
       while (blength && (*b == '+' || *b == '0'))
       {
-	b++; blength--;
+        b++; blength--;
       }
       if (alength != blength)
-	return (alength < blength) ? -1 : 1;
+        return (alength < blength) ? -1 : 1;
       while (a < end)
-	if (*a++ !=  *b++)
-	  return ((int) a[-1] - (int) b[-1]);
+        if (*a++ !=  *b++)
+          return ((int) a[-1] - (int) b[-1]);
 
-      if (swap_flag)				/* Restore pointers */
-	swap(uchar*,a,b);
+      if (swap_flag)                            /* Restore pointers */
+        swap(uchar*,a,b);
       break;
     }
 #ifdef HAVE_LONG_LONG
@@ -765,7 +967,7 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
       a=  end;
       b+= 8;
       break;
@@ -776,14 +978,14 @@ int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
       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);
+        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 */
+    case HA_KEYTYPE_END:                        /* Ready */
+      goto end;                                 /* diff_pos is incremented */
     }
   }
   (*diff_pos)++;
@@ -798,33 +1000,33 @@ end:
     {
       if (*a++ != *b++)
       {
-	flag= FCMP(a[-1],b[-1]);
-	break;
+        flag= FCMP(a[-1],b[-1]);
+        break;
       }
     }
     if (nextflag & SEARCH_SAME)
-      return (flag);				/* read same */
+      return (flag);                            /* read same */
     if (nextflag & SEARCH_BIGGER)
-      return (flag <= 0 ? -1 : 1);		/* read next */
-    return (flag < 0 ? -1 : 1);			/* read previous */
+      return (flag <= 0 ? -1 : 1);              /* read next */
+    return (flag < 0 ? -1 : 1);                 /* read previous */
   }
   return 0;
 } /* _mi_key_cmp */
 
 
-	/* Get key from key-block */
-	/* page points at previous key; its advanced to point at next key */
-	/* key should contain previous key */
-	/* Returns length of found key + pointers */
-	/* nod_flag is a flag if we are on nod */
+        /* Get key from key-block */
+        /* page points at previous key; its advanced to point at next key */
+        /* key should contain previous key */
+        /* Returns length of found key + pointers */
+        /* nod_flag is a flag if we are on nod */
 
-	/* same as _mi_get_key but used with fixed length keys */
+        /* same as _mi_get_key but used with fixed length keys */
 
 uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
-		       register uchar **page, register uchar *key)
+                       register uchar **page, register uchar *key)
 {
   memcpy((byte*) key,(byte*) *page,
-	 (size_t) (keyinfo->keylength+nod_flag));
+         (size_t) (keyinfo->keylength+nod_flag));
   *page+=keyinfo->keylength+nod_flag;
   return(keyinfo->keylength);
 } /* _mi_get_static_key */
@@ -833,7 +1035,7 @@ uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 /* Key with is packed against previous key or key with a NULL column */
 
 uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
-		      register uchar **page_pos, register uchar *key)
+                      register uchar **page_pos, register uchar *key)
 {
   reg1 MI_KEYSEG *keyseg;
   uchar *start_key,*page=*page_pos;
@@ -849,85 +1051,85 @@ uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
       uint packed= *page & 128,tot_length,rest_length;
       if (keyseg->length >= 127)
       {
-	length=mi_uint2korr(page) & 32767;
-	page+=2;
+        length=mi_uint2korr(page) & 32767;
+        page+=2;
       }
       else
-	length= *page++ & 127;
+        length= *page++ & 127;
 
       if (packed)
       {
-	if (length > (uint) keyseg->length)
-	{
-	  my_errno=HA_ERR_CRASHED;
-	  return 0;				/* Error */
-	}
-	if (length == 0)			/* Same key */
-	{
-	  if (keyseg->flag & HA_NULL_PART)
-	    *key++=1;				/* Can't be NULL */
-	  get_key_length(length,key);
-	  key+= length;				/* Same diff_key as prev */
-	  if (length > keyseg->length)
-	  {
-	    DBUG_PRINT("error",("Found too long null packed key: %d of %d at %lx",
-				length, keyseg->length, *page_pos));
-	    DBUG_DUMP("key",(char*) *page_pos,16);
-	    my_errno=HA_ERR_CRASHED;
-	    return 0;
-	  }
-	  continue;
-	}
-	if (keyseg->flag & HA_NULL_PART)
-	  key++;				/* Skipp null marker*/
-
-	get_key_length(rest_length,page);
-	tot_length=rest_length+length;
-
-	/* If the stored length has changed, we must move the key */
-	if (tot_length >= 255 && *start != 255)
-	{
-	  /* length prefix changed from a length of one to a length of 3 */
-	  bmove_upp((char*) key+length+3,(char*) key+length+1,length);
-	  *key=255;
-	  mi_int2store(key+1,tot_length);
-	  key+=3+length;
-	}
-	else if (tot_length < 255 && *start == 255)
-	{
-	  bmove(key+1,key+3,length);
-	  *key=tot_length;
-	  key+=1+length;
-	}
-	else
-	{
-	  store_key_length_inc(key,tot_length);
-	  key+=length;
-	}
-	memcpy(key,page,rest_length);
-	page+=rest_length;
-	key+=rest_length;
-	continue;
+        if (length > (uint) keyseg->length)
+        {
+          my_errno=HA_ERR_CRASHED;
+          return 0;                             /* Error */
+        }
+        if (length == 0)                        /* Same key */
+        {
+          if (keyseg->flag & HA_NULL_PART)
+            *key++=1;                           /* Can't be NULL */
+          get_key_length(length,key);
+          key+= length;                         /* Same diff_key as prev */
+          if (length > keyseg->length)
+          {
+            DBUG_PRINT("error",("Found too long null packed key: %d of %d at %lx",
+                                length, keyseg->length, *page_pos));
+            DBUG_DUMP("key",(char*) *page_pos,16);
+            my_errno=HA_ERR_CRASHED;
+            return 0;
+          }
+          continue;
+        }
+        if (keyseg->flag & HA_NULL_PART)
+          key++;                                /* Skipp null marker*/
+
+        get_key_length(rest_length,page);
+        tot_length=rest_length+length;
+
+        /* If the stored length has changed, we must move the key */
+        if (tot_length >= 255 && *start != 255)
+        {
+          /* length prefix changed from a length of one to a length of 3 */
+          bmove_upp((char*) key+length+3,(char*) key+length+1,length);
+          *key=255;
+          mi_int2store(key+1,tot_length);
+          key+=3+length;
+        }
+        else if (tot_length < 255 && *start == 255)
+        {
+          bmove(key+1,key+3,length);
+          *key=tot_length;
+          key+=1+length;
+        }
+        else
+        {
+          store_key_length_inc(key,tot_length);
+          key+=length;
+        }
+        memcpy(key,page,rest_length);
+        page+=rest_length;
+        key+=rest_length;
+        continue;
       }
       else
       {
-	if (keyseg->flag & HA_NULL_PART)
-	{
-	  if (!length--)			/* Null part */
-	  {
-	    *key++=0;
-	    continue;
-	  }
-	  *key++=1;				/* Not null */
-	}
+        if (keyseg->flag & HA_NULL_PART)
+        {
+          if (!length--)                        /* Null part */
+          {
+            *key++=0;
+            continue;
+          }
+          *key++=1;                             /* Not null */
+        }
       }
       if (length > (uint) keyseg->length)
       {
-	DBUG_PRINT("error",("Found too long packed key: %d of %d at %lx",
-			    length, keyseg->length, *page_pos));
-	DBUG_DUMP("key",(char*) *page_pos,16);
-	my_errno=HA_ERR_CRASHED;
-	return 0;				/* Error */
+        DBUG_PRINT("error",("Found too long packed key: %d of %d at %lx",
+                            length, keyseg->length, *page_pos));
+        DBUG_DUMP("key",(char*) *page_pos,16);
+        my_errno=HA_ERR_CRASHED;
+        return 0;                               /* Error */
       }
       store_key_length_inc(key,length);
     }
@@ -935,18 +1137,18 @@ uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
     {
       if (keyseg->flag & HA_NULL_PART)
       {
-	if (!(*key++ = *page++))
-	  continue;
+        if (!(*key++ = *page++))
+          continue;
       }
       if (keyseg->flag &
-	  (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
+          (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
       {
-	uchar *tmp=page;
-	get_key_length(length,tmp);
-	length+=(uint) (tmp-page);
+        uchar *tmp=page;
+        get_key_length(length,tmp);
+        length+=(uint) (tmp-page);
       }
       else
-	length=keyseg->length;
+        length=keyseg->length;
     }
     memcpy((byte*) key,(byte*) page,(size_t) length);
     key+=length;
@@ -963,7 +1165,7 @@ uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 /* key that is packed relatively to previous */
 
 uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
-			     register uchar **page_pos, register uchar *key)
+                             register uchar **page_pos, register uchar *key)
 {
   reg1 MI_KEYSEG *keyseg;
   uchar *start_key,*page=*page_pos,*page_end,*from,*from_end;
@@ -978,16 +1180,16 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
     if (length > keyinfo->maxlength)
     {
       DBUG_PRINT("error",("Found too long binary packed key: %d of %d at %lx",
-			  length, keyinfo->maxlength, *page_pos));
+                          length, keyinfo->maxlength, *page_pos));
       DBUG_DUMP("key",(char*) *page_pos,16);
       my_errno=HA_ERR_CRASHED;
-      return 0;					/* Wrong key */
+      return 0;                                 /* Wrong key */
     }
     from=key;  from_end=key+length;
   }
   else
   {
-    from=page; from_end=page_end;		/* Not packed key */
+    from=page; from_end=page_end;               /* Not packed key */
   }
 
   /*
@@ -1001,7 +1203,7 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
     {
       if (from == from_end) { from=page;  from_end=page_end; }
       if (!(*key++ = *from++))
-	continue;				/* Null part */
+        continue;                               /* Null part */
     }
     if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
     {
@@ -1009,10 +1211,10 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
       if (from == from_end) { from=page;  from_end=page_end; }
       if ((length= (*key++ = *from++)) == 255)
       {
-	if (from == from_end) { from=page;  from_end=page_end; }
-	length= (uint) ((*key++ = *from++)) << 8;
-	if (from == from_end) { from=page;  from_end=page_end; }
-	length+= (uint) ((*key++ = *from++));
+        if (from == from_end) { from=page;  from_end=page_end; }
+        length= (uint) ((*key++ = *from++)) << 8;
+        if (from == from_end) { from=page;  from_end=page_end; }
+        length+= (uint) ((*key++ = *from++));
       }
     }
     else
@@ -1020,7 +1222,7 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
     if ((tmp=(uint) (from_end-from)) <= length)
     {
-      key+=tmp;					/* Use old key */
+      key+=tmp;                                 /* Use old key */
       length-=tmp;
       from=page; from_end=page_end;
     }
@@ -1031,7 +1233,7 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
   length=keyseg->length+nod_flag;
   if ((tmp=(uint) (from_end-from)) <= length)
   {
-    memcpy(key+tmp,page,length-tmp);		/* Get last part of key */
+    memcpy(key+tmp,page,length-tmp);            /* Get last part of key */
     *page_pos= page+length-tmp;
   }
   else
@@ -1040,7 +1242,7 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
     {
       DBUG_PRINT("error",("Error when unpacking key"));
       my_errno=HA_ERR_CRASHED;
-      return 0;					/* Error */
+      return 0;                                 /* Error */
     }
     memcpy((byte*) key,(byte*) from,(size_t) length);
     *page_pos= from+length;
@@ -1049,11 +1251,11 @@ uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 }
 
 
-	/* Get key at position without knowledge of previous key */
-	/* Returns pointer to next key */
+        /* Get key at position without knowledge of previous key */
+        /* Returns pointer to next key */
 
 uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
-		   uchar *key, uchar *keypos, uint *return_key_length)
+                   uchar *key, uchar *keypos, uint *return_key_length)
 {
   uint nod_flag;
   DBUG_ENTER("_mi_get_key");
@@ -1067,14 +1269,14 @@ uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
   else
   {
     page+=2+nod_flag;
-    key[0]=0;					/* safety */
+    key[0]=0;                                   /* safety */
     while (page <= keypos)
     {
       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
       if (*return_key_length == 0)
       {
-	my_errno=HA_ERR_CRASHED;
-	DBUG_RETURN(0);
+        my_errno=HA_ERR_CRASHED;
+        DBUG_RETURN(0);
       }
     }
   }
@@ -1083,12 +1285,12 @@ uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 } /* _mi_get_key */
 
 
-	/* Get key at position without knowledge of previous key */
-	/* Returns 0 if ok */
+        /* Get key at position without knowledge of previous key */
+        /* Returns 0 if ok */
 
 static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
-				uchar *key, uchar *keypos,
-				uint *return_key_length)
+                                uchar *key, uchar *keypos,
+                                uint *return_key_length)
 {
   uint nod_flag;
   DBUG_ENTER("_mi_get_prev_key");
@@ -1098,20 +1300,20 @@ static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
   {
     *return_key_length=keyinfo->keylength;
     bmove((byte*) key,(byte*) keypos- *return_key_length-nod_flag,
-	  *return_key_length);
+          *return_key_length);
     DBUG_RETURN(0);
   }
   else
   {
     page+=2+nod_flag;
-    key[0]=0;					/* safety */
+    key[0]=0;                                   /* safety */
     while (page < keypos)
     {
       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
       if (*return_key_length == 0)
       {
-	my_errno=HA_ERR_CRASHED;
-	DBUG_RETURN(1);
+        my_errno=HA_ERR_CRASHED;
+        DBUG_RETURN(1);
       }
     }
   }
@@ -1120,11 +1322,11 @@ static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
 
 
-	/* Get last key from key-page */
-	/* Return pointer to where key starts */
+        /* Get last key from key-page */
+        /* Return pointer to where key starts */
 
 uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
-			uchar *lastkey, uchar *endpos, uint *return_key_length)
+                        uchar *lastkey, uchar *endpos, uint *return_key_length)
 {
   uint nod_flag;
   uchar *lastpos;
@@ -1149,9 +1351,9 @@ uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,lastkey);
       if (*return_key_length == 0)
       {
-	DBUG_PRINT("error",("Couldn't find last key:  page: %lx",page));
-	my_errno=HA_ERR_CRASHED;
-	DBUG_RETURN(0);
+        DBUG_PRINT("error",("Couldn't find last key:  page: %lx",page));
+        my_errno=HA_ERR_CRASHED;
+        DBUG_RETURN(0);
       }
     }
   }
@@ -1160,7 +1362,7 @@ uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 } /* _mi_get_last_key */
 
 
-	/* Calculate length of key */
+        /* Calculate length of key */
 
 uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
 {
@@ -1175,7 +1377,7 @@ uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
   {
     if (keyseg->flag & HA_NULL_PART)
       if (!*key++)
-	continue;
+        continue;
     if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH))
     {
       uint length;
@@ -1189,28 +1391,28 @@ uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
 } /* _mi_keylength */
 
 
-	/* Move a key */
+        /* Move a key */
 
 uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
 {
   reg1 uint length;
   memcpy((byte*) to, (byte*) from,
-	 (size_t) (length=_mi_keylength(keyinfo,from)));
+         (size_t) (length=_mi_keylength(keyinfo,from)));
   return to+length;
 }
 
-	/* Find next/previous record with same key */
-	/* This can't be used when database is touched after last read */
+        /* Find next/previous record with same key */
+        /* This can't be used when database is touched after last read */
 
 int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
-		    uchar *key, uint key_length, uint nextflag, my_off_t pos)
+                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
 {
   int error;
   uint nod_flag;
   uchar lastkey[MI_MAX_KEY_BUFF];
   DBUG_ENTER("_mi_search_next");
   DBUG_PRINT("enter",("nextflag: %d  lastpos: %ld  int_keypos: %lx",
-		       nextflag,(long) info->lastpos,info->int_keypos));
+                       nextflag,(long) info->lastpos,info->int_keypos));
   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,key_length););
 
   /* Force full read if we are at last key or if we are not on a leaf
@@ -1225,12 +1427,12 @@ int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       (info->int_keytree_version != keyinfo->version &&
        (info->int_nod_flag || info->buff_used)))
     DBUG_RETURN(_mi_search(info,keyinfo,key,key_length,
-			   nextflag | SEARCH_SAVE_BUFF, pos));
+                           nextflag | SEARCH_SAVE_BUFF, pos));
 
   if (info->buff_used)
   {
     if (!_mi_fetch_keypage(info,keyinfo,info->last_search_keypage,
-			   info->buff,0))
+                           info->buff,0))
       DBUG_RETURN(-1);
     info->buff_used=0;
   }
@@ -1239,36 +1441,36 @@ int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   nod_flag=mi_test_if_nod(info->buff);
   memcpy(lastkey,key,key_length);
 
-  if (nextflag & SEARCH_BIGGER)					/* Next key */
+  if (nextflag & SEARCH_BIGGER)                                 /* Next key */
   {
     my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
     if (tmp_pos != HA_OFFSET_ERROR)
     {
       if ((error=_mi_search(info,keyinfo,key,key_length,
-			    nextflag | SEARCH_SAVE_BUFF, tmp_pos)) <=0)
-	DBUG_RETURN(error);
+                            nextflag | SEARCH_SAVE_BUFF, tmp_pos)) <=0)
+        DBUG_RETURN(error);
     }
     if (!(info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,
-						   &info->int_keypos,lastkey)))
+                                                   &info->int_keypos,lastkey)))
       DBUG_RETURN(-1);
   }
-  else							/* Previous key */
+  else                                                  /* Previous key */
   {
     uint length;
     /* Find start of previous key */
     info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
-				      info->int_keypos, &length);
+                                      info->int_keypos, &length);
     if (!info->int_keypos)
       DBUG_RETURN(-1);
     if (info->int_keypos == info->buff+2)
       DBUG_RETURN(_mi_search(info,keyinfo,key,key_length,
-			     nextflag | SEARCH_SAVE_BUFF, pos));
+                             nextflag | SEARCH_SAVE_BUFF, pos));
     if ((error=_mi_search(info,keyinfo,key,0,nextflag | SEARCH_SAVE_BUFF,
-			  _mi_kpos(nod_flag,info->int_keypos))) <= 0)
+                          _mi_kpos(nod_flag,info->int_keypos))) <= 0)
       DBUG_RETURN(error);
 
     if (! _mi_get_last_key(info,keyinfo,info->buff,lastkey,
-			   info->int_keypos,&info->lastkey_length))
+                           info->int_keypos,&info->lastkey_length))
       DBUG_RETURN(-1);
   }
   memcpy(info->lastkey,lastkey,info->lastkey_length);
@@ -1278,11 +1480,11 @@ int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 } /* _mi_search_next */
 
 
-	/* Search after position for the first row in an index */
-	/* This is stored in info->lastpos */
+        /* Search after position for the first row in an index */
+        /* This is stored in info->lastpos */
 
 int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
-		     register my_off_t pos)
+                     register my_off_t pos)
 {
   uint nod_flag;
   uchar *page;
@@ -1307,7 +1509,7 @@ int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   } while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
 
   info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,
-					   info->lastkey);
+                                           info->lastkey);
   info->int_keypos=page; info->int_maxpos=info->buff+mi_getint(info->buff)-1;
   info->int_nod_flag=nod_flag;
   info->int_keytree_version=keyinfo->version;
@@ -1320,11 +1522,11 @@ int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 } /* _mi_search_first */
 
 
-	/* Search after position for the last row in an index */
-	/* This is stored in info->lastpos */
+        /* Search after position for the last row in an index */
+        /* This is stored in info->lastpos */
 
 int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
-		    register my_off_t pos)
+                    register my_off_t pos)
 {
   uint nod_flag;
   uchar *buff,*page;
@@ -1332,7 +1534,7 @@ int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 
   if (pos == HA_OFFSET_ERROR)
   {
-    my_errno=HA_ERR_KEY_NOT_FOUND;			/* Didn't find key */
+    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
     info->lastpos= HA_OFFSET_ERROR;
     DBUG_RETURN(-1);
   }
@@ -1350,7 +1552,7 @@ int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   } while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
 
   if (!_mi_get_last_key(info,keyinfo,buff,info->lastkey,page,
-			&info->lastkey_length))
+                        &info->lastkey_length))
     DBUG_RETURN(-1);
   info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
   info->int_keypos=info->int_maxpos=page;
@@ -1370,22 +1572,22 @@ int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 ** Functions to store and pack a key in a page
 **
 ** mi_calc_xx_key_length takes the following arguments:
-**  nod_flag	If nod: Length of nod-pointer
-**  next_key	Position to pos after the new key in buffer
-**  org_key	Key that was before the next key in buffer
-**  prev_key	Last key before current key
-**  key		Key that will be stored
-**  s_temp	Information how next key will be packed
+**  nod_flag    If nod: Length of nod-pointer
+**  next_key    Position to pos after the new key in buffer
+**  org_key     Key that was before the next key in buffer
+**  prev_key    Last key before current key
+**  key         Key that will be stored
+**  s_temp      Information how next key will be packed
 ****************************************************************************/
 
 /* Static length key */
 
 int
 _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
-			   uchar *next_pos  __attribute__((unused)),
-			   uchar *org_key  __attribute__((unused)),
-			   uchar *prev_key __attribute__((unused)),
-			   uchar *key, MI_KEY_PARAM *s_temp)
+                           uchar *next_pos  __attribute__((unused)),
+                           uchar *org_key  __attribute__((unused)),
+                           uchar *prev_key __attribute__((unused)),
+                           uchar *key, MI_KEY_PARAM *s_temp)
 {
   s_temp->key=key;
   return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
@@ -1395,10 +1597,10 @@ _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
 int
 _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
-			uchar *next_pos  __attribute__((unused)),
-			uchar *org_key  __attribute__((unused)),
-			uchar *prev_key __attribute__((unused)),
-			uchar *key, MI_KEY_PARAM *s_temp)
+                        uchar *next_pos  __attribute__((unused)),
+                        uchar *org_key  __attribute__((unused)),
+                        uchar *prev_key __attribute__((unused)),
+                        uchar *key, MI_KEY_PARAM *s_temp)
 {
   s_temp->key=key;
   return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
@@ -1413,10 +1615,10 @@ _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
   If the max length of first key segment <= 127 characters the prefix is
   1 byte else it's 2 byte
 
-  prefix byte	 The high bit is set if this is a prefix for the prev key
-  length	 Packed length if the previous was a prefix byte
-  [length]	 Length character of data
-  next-key-seg	 Next key segments
+  prefix byte    The high bit is set if this is a prefix for the prev key
+  length         Packed length if the previous was a prefix byte
+  [length]       Length character of data
+  next-key-seg   Next key segments
 
   If the first segment can have NULL:
   The length is 0 for NULLS and 1+length for not null columns.
@@ -1425,8 +1627,8 @@ _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
 int
 _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
-			     uchar *org_key, uchar *prev_key, uchar *key,
-			     MI_KEY_PARAM *s_temp)
+                             uchar *org_key, uchar *prev_key, uchar *key,
+                             MI_KEY_PARAM *s_temp)
 {
   reg1 MI_KEYSEG *keyseg;
   int length;
@@ -1467,15 +1669,15 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
       s_temp->key=key;
       s_temp->ref_length=s_temp->key_length=0;
       s_temp->totlength=key_length-1+diff_flag;
-      s_temp->next_key_pos=0;			/* No next key */
+      s_temp->next_key_pos=0;                   /* No next key */
       return (s_temp->totlength);
     }
     s_temp->store_not_null=1;
-    key_length--;				/* We don't store NULL */
+    key_length--;                               /* We don't store NULL */
     if (prev_key && !*prev_key++)
-      org_key=prev_key=0;			/* Can't pack against prev */
+      org_key=prev_key=0;                       /* Can't pack against prev */
     else if (org_key)
-      org_key++;				/* Skipp NULL */
+      org_key++;                                /* Skipp NULL */
   }
   else
     s_temp->store_not_null=0;
@@ -1491,14 +1693,14 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
   if (prev_key)
   {
     get_key_length(org_key_length,prev_key);
-    s_temp->prev_key=prev_key;		/* Pointer at data */
+    s_temp->prev_key=prev_key;          /* Pointer at data */
     /* Don't use key-pack if length == 0 */
     if (new_key_length && new_key_length == org_key_length)
       same_length=1;
     else if (new_key_length > org_key_length)
       end=key + org_key_length;
 
-    if (sort_order)				/* SerG */
+    if (sort_order)                             /* SerG */
     {
       while (key < end && sort_order[*key] == sort_order[*prev_key])
       {
@@ -1509,7 +1711,7 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     {
       while (key < end && *key == *prev_key)
       {
-	key++; prev_key++;
+        key++; prev_key++;
       }
     }
   }
@@ -1524,15 +1726,15 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     length=(int) key_length-(int) (key_end-start)-length_pack;
     length+= diff_flag;
     if (next_key)
-    {						/* Can't combine with next */
-      s_temp->n_length= *next_key;		/* Needed by _mi_store_key */
+    {                                           /* Can't combine with next */
+      s_temp->n_length= *next_key;              /* Needed by _mi_store_key */
       next_key=0;
     }
   }
   else
   {
     if (start != key)
-    {						/* Starts as prev key */
+    {                                           /* Starts as prev key */
       ref_length= (uint) (key-start);
       s_temp->ref_length= ref_length + pack_marker;
       length= (int) (key_length - ref_length);
@@ -1543,16 +1745,16 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     }
     else
     {
-      s_temp->key_length+=s_temp->store_not_null;	/* If null */
+      s_temp->key_length+=s_temp->store_not_null;       /* If null */
       length= key_length - length_pack+ diff_flag;
     }
   }
   s_temp->totlength=(uint) length;
   s_temp->prev_length=0;
   DBUG_PRINT("test",("tot_length: %d  length: %d  uniq_key_length: %d",
-		     key_length,length,s_temp->key_length));
+                     key_length,length,s_temp->key_length));
 
-	/* If something after that hasn't length=0, test if we can combine */
+        /* If something after that hasn't length=0, test if we can combine */
   if ((s_temp->next_key_pos=next_key))
   {
     uint packed,n_length;
@@ -1568,134 +1770,134 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     if (!packed)
       n_length-= s_temp->store_not_null;
 
-    if (n_length || packed)		/* Don't pack 0 length keys */
+    if (n_length || packed)             /* Don't pack 0 length keys */
     {
       uint next_length_pack, new_ref_length=s_temp->ref_length;
 
       if (packed)
       {
-	/* If first key and next key is packed (only on delete) */
-	if (!prev_key && org_key)
-	{
-	  get_key_length(org_key_length,org_key);
-	  key=start;
-	  if (sort_order)			/* SerG */
-	  {
-	    while (key < end && sort_order[*key] == sort_order[*org_key])
-	    {
-	      key++; org_key++;
-	    }
-	  }
-	  else
-	  {
-	    while (key < end && *key == *org_key)
-	    {
-	      key++; org_key++;
-	    }
-	  }
-	  if ((new_ref_length= (uint) (key - start)))
-	    new_ref_length+=pack_marker;
-	}
-
-	if (!n_length)
-	{
-	  /*
-	    We put a different key between two identical variable length keys
-	    Extend next key to have same prefix as this key
-	  */
-	  if (new_ref_length)			/* prefix of previus key */
-	  {					/* make next key longer */
-	    s_temp->part_of_prev_key= new_ref_length;
-	    s_temp->prev_length=	  org_key_length -
-	      (new_ref_length-pack_marker);
-	    s_temp->n_ref_length= s_temp->n_length= s_temp->prev_length;
-	    n_length=		  get_pack_length(s_temp->prev_length);
-	    s_temp->prev_key+=	  (new_ref_length - pack_marker);
-	    length+=		  s_temp->prev_length + n_length;
-	  }
-	  else
-	  {					/* Can't use prev key */
-	    s_temp->part_of_prev_key=0;
-	    s_temp->prev_length= org_key_length;
-	    s_temp->n_ref_length=s_temp->n_length=  org_key_length;
-	    length+=	       org_key_length;
-	    /* +get_pack_length(org_key_length); */
-	  }
-	  return (int) length;
-	}
-
-	ref_length=n_length;
-	get_key_pack_length(n_length,next_length_pack,next_key);
-
-	/* Test if new keys has fewer characters that match the previous key */
-	if (!new_ref_length)
-	{					/* Can't use prev key */
-	  s_temp->part_of_prev_key=	0;
-	  s_temp->prev_length=		ref_length;
-	  s_temp->n_ref_length= s_temp->n_length= n_length+ref_length;
-	  /* s_temp->prev_key+=		get_pack_length(org_key_length); */
-	  return (int) length+ref_length-next_length_pack;
-	}
-	if (ref_length+pack_marker > new_ref_length)
-	{
-	  uint new_pack_length=new_ref_length-pack_marker;
-	  /* We must copy characters from the original key to the next key */
-	  s_temp->part_of_prev_key= new_ref_length;
-	  s_temp->prev_length=	    ref_length - new_pack_length;
-	  s_temp->n_ref_length=s_temp->n_length=n_length + s_temp->prev_length;
-	  s_temp->prev_key+=	    new_pack_length;
-/*				    +get_pack_length(org_key_length); */
-	  length= length-get_pack_length(ref_length)+
-	    get_pack_length(new_pack_length);
-	  return (int) length + s_temp->prev_length;
-	}
+        /* If first key and next key is packed (only on delete) */
+        if (!prev_key && org_key)
+        {
+          get_key_length(org_key_length,org_key);
+          key=start;
+          if (sort_order)                       /* SerG */
+          {
+            while (key < end && sort_order[*key] == sort_order[*org_key])
+            {
+              key++; org_key++;
+            }
+          }
+          else
+          {
+            while (key < end && *key == *org_key)
+            {
+              key++; org_key++;
+            }
+          }
+          if ((new_ref_length= (uint) (key - start)))
+            new_ref_length+=pack_marker;
+        }
+
+        if (!n_length)
+        {
+          /*
+            We put a different key between two identical variable length keys
+            Extend next key to have same prefix as this key
+          */
+          if (new_ref_length)                   /* prefix of previus key */
+          {                                     /* make next key longer */
+            s_temp->part_of_prev_key= new_ref_length;
+            s_temp->prev_length=          org_key_length -
+              (new_ref_length-pack_marker);
+            s_temp->n_ref_length= s_temp->n_length= s_temp->prev_length;
+            n_length=             get_pack_length(s_temp->prev_length);
+            s_temp->prev_key+=    (new_ref_length - pack_marker);
+            length+=              s_temp->prev_length + n_length;
+          }
+          else
+          {                                     /* Can't use prev key */
+            s_temp->part_of_prev_key=0;
+            s_temp->prev_length= org_key_length;
+            s_temp->n_ref_length=s_temp->n_length=  org_key_length;
+            length+=           org_key_length;
+            /* +get_pack_length(org_key_length); */
+          }
+          return (int) length;
+        }
+
+        ref_length=n_length;
+        get_key_pack_length(n_length,next_length_pack,next_key);
+
+        /* Test if new keys has fewer characters that match the previous key */
+        if (!new_ref_length)
+        {                                       /* Can't use prev key */
+          s_temp->part_of_prev_key=     0;
+          s_temp->prev_length=          ref_length;
+          s_temp->n_ref_length= s_temp->n_length= n_length+ref_length;
+          /* s_temp->prev_key+=         get_pack_length(org_key_length); */
+          return (int) length+ref_length-next_length_pack;
+        }
+        if (ref_length+pack_marker > new_ref_length)
+        {
+          uint new_pack_length=new_ref_length-pack_marker;
+          /* We must copy characters from the original key to the next key */
+          s_temp->part_of_prev_key= new_ref_length;
+          s_temp->prev_length=      ref_length - new_pack_length;
+          s_temp->n_ref_length=s_temp->n_length=n_length + s_temp->prev_length;
+          s_temp->prev_key+=        new_pack_length;
+/*                                  +get_pack_length(org_key_length); */
+          length= length-get_pack_length(ref_length)+
+            get_pack_length(new_pack_length);
+          return (int) length + s_temp->prev_length;
+        }
       }
       else
       {
-	/* Next key wasn't a prefix of previous key */
-	ref_length=0;
-	next_length_pack=0;
+        /* Next key wasn't a prefix of previous key */
+        ref_length=0;
+        next_length_pack=0;
      }
       DBUG_PRINT("test",("length: %d  next_key: %lx",length,next_key));
 
       {
-	uint tmp_length;
-	key=(start+=ref_length);
-	if (key+n_length < key_end)		/* Normalize length based */
-	  key_end=key+n_length;
-	if (sort_order)				/* SerG */
-	{
+        uint tmp_length;
+        key=(start+=ref_length);
+        if (key+n_length < key_end)             /* Normalize length based */
+          key_end=key+n_length;
+        if (sort_order)                         /* SerG */
+        {
           while (key < key_end && sort_order[*key] ==
-		 sort_order[*next_key])
-	  {
-	    key++; next_key++;
-	  }
-	}
-	else
-	{
-	  while (key < key_end && *key == *next_key)
-	  {
-	    key++; next_key++;
-	  }
-	}
-	if (!(tmp_length=(uint) (key-start)))
-	{					/* Key can't be re-packed */
-	  s_temp->next_key_pos=0;
-	  return length;
-	}
-	ref_length+=tmp_length;
-	n_length-=tmp_length;
-	length-=tmp_length+next_length_pack;	/* We gained these chars */
+                 sort_order[*next_key])
+          {
+            key++; next_key++;
+          }
+        }
+        else
+        {
+          while (key < key_end && *key == *next_key)
+          {
+            key++; next_key++;
+          }
+        }
+        if (!(tmp_length=(uint) (key-start)))
+        {                                       /* Key can't be re-packed */
+          s_temp->next_key_pos=0;
+          return length;
+        }
+        ref_length+=tmp_length;
+        n_length-=tmp_length;
+        length-=tmp_length+next_length_pack;    /* We gained these chars */
       }
       if (n_length == 0)
       {
-	s_temp->n_ref_length=pack_marker;	/* Same as prev key */
+        s_temp->n_ref_length=pack_marker;       /* Same as prev key */
       }
       else
       {
-	s_temp->n_ref_length=ref_length | pack_marker;
-	length+= get_pack_length(n_length);
-	s_temp->n_length=n_length;
+        s_temp->n_ref_length=ref_length | pack_marker;
+        length+= get_pack_length(n_length);
+        s_temp->n_length=n_length;
       }
     }
   }
@@ -1707,15 +1909,15 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 
 int
 _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
-			     uchar *org_key, uchar *prev_key, uchar *key,
-			     MI_KEY_PARAM *s_temp)
+                             uchar *org_key, uchar *prev_key, uchar *key,
+                             MI_KEY_PARAM *s_temp)
 {
   uint length,key_length,ref_length;
 
   s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
   s_temp->key=key;
   s_temp->prev_key=org_key;
-  if (prev_key)					/* If not first key in block */
+  if (prev_key)                                 /* If not first key in block */
   {
     /* pack key against previous key */
     /*
@@ -1734,7 +1936,7 @@ _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     s_temp->ref_length=ref_length=0;
     length=key_length+1;
   }
-  if ((s_temp->next_key_pos=next_key))		/* If another key after */
+  if ((s_temp->next_key_pos=next_key))          /* If another key after */
   {
     /* pack key against next key */
     uint next_length,next_length_pack;
@@ -1745,21 +1947,21 @@ _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     {
       uchar *end;
       for (key= s_temp->key, end=key+next_length ;
-	   *key == *org_key && key < end;
-	   key++,org_key++) ;
+           *key == *org_key && key < end;
+           key++,org_key++) ;
       ref_length= (uint) (key - s_temp->key);
     }
 
     if (next_length > ref_length)
     {
       /* We put a key with different case between two keys with the same prefix
-	 Extend next key to have same prefix as
-	 this key */
+         Extend next key to have same prefix as
+         this key */
       s_temp->n_ref_length= ref_length;
       s_temp->prev_length=  next_length-ref_length;
       s_temp->prev_key+=    ref_length;
       return (int) (length+ s_temp->prev_length - next_length_pack +
-		    get_pack_length(ref_length));
+                    get_pack_length(ref_length));
     }
     /* Check how many characters are identical to next key */
     key= s_temp->key+next_length;
@@ -1767,12 +1969,12 @@ _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     if ((ref_length= (uint) (key - s_temp->key)-1) == next_length)
     {
       s_temp->next_key_pos=0;
-      return length;				/* can't pack next key */
+      return length;                            /* can't pack next key */
     }
     s_temp->prev_length=0;
     s_temp->n_ref_length=ref_length;
     return (int) (length-(ref_length - next_length) - next_length_pack +
-		  get_pack_length(ref_length));
+                  get_pack_length(ref_length));
   }
   return (int) length;
 }
@@ -1785,8 +1987,8 @@ _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 /* store key without compression */
 
 void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
-			  register uchar *key_pos,
-			  register MI_KEY_PARAM *s_temp)
+                          register uchar *key_pos,
+                          register MI_KEY_PARAM *s_temp)
 {
   memcpy((byte*) key_pos,(byte*) s_temp->key,(size_t) s_temp->totlength);
 }
@@ -1800,8 +2002,8 @@ void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
 
 
 void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
-			    register uchar *key_pos,
-			    register MI_KEY_PARAM *s_temp)
+                            register uchar *key_pos,
+                            register MI_KEY_PARAM *s_temp)
 {
   uint length;
   uchar *start;
@@ -1822,9 +2024,9 @@ void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->key_length);
   }
   bmove((byte*) key_pos,(byte*) s_temp->key,
-	(length=s_temp->totlength-(uint) (key_pos-start)));
+        (length=s_temp->totlength-(uint) (key_pos-start)));
 
-  if (!s_temp->next_key_pos)			/* No following key */
+  if (!s_temp->next_key_pos)                    /* No following key */
     return;
   key_pos+=length;
 
@@ -1834,14 +2036,14 @@ void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
     if (s_temp->part_of_prev_key)
     {
       store_pack_length(s_temp->pack_marker == 128,key_pos,
-			s_temp->part_of_prev_key);
+                        s_temp->part_of_prev_key);
       store_key_length_inc(key_pos,s_temp->n_length);
     }
     else
     {
       s_temp->n_length+= s_temp->store_not_null;
       store_pack_length(s_temp->pack_marker == 128,key_pos,
-			s_temp->n_length);
+                        s_temp->n_length);
     }
     memcpy(key_pos, s_temp->prev_key, s_temp->prev_length);
   }
@@ -1849,7 +2051,7 @@ void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
   {
     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->n_ref_length);
     if (s_temp->n_ref_length == s_temp->pack_marker)
-      return;					/* Identical key */
+      return;                                   /* Identical key */
     store_key_length(key_pos,s_temp->n_length);
   }
   else
@@ -1863,18 +2065,18 @@ void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
 /* variable length key with prefix compression */
 
 void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
-			    register uchar *key_pos,
-			    register MI_KEY_PARAM *s_temp)
+                            register uchar *key_pos,
+                            register MI_KEY_PARAM *s_temp)
 {
   store_key_length_inc(key_pos,s_temp->ref_length);
   memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
-	  (size_t) s_temp->totlength-s_temp->ref_length);
+          (size_t) s_temp->totlength-s_temp->ref_length);
 
   if (s_temp->next_key_pos)
   {
     key_pos+=(uint) (s_temp->totlength-s_temp->ref_length);
     store_key_length_inc(key_pos,s_temp->n_ref_length);
-    if (s_temp->prev_length)			/* If we must extend key */
+    if (s_temp->prev_length)                    /* If we must extend key */
     {
       memcpy(key_pos,s_temp->prev_key,s_temp->prev_length);
     }