Merge with 4.1.3-beta

BitKeeper/etc/ignore:
  auto-union
BitKeeper/etc/logging_ok:
  auto-union
VC++Files/libmysqld/libmysqld.dsp:
  Auto merged
VC++Files/sql/mysqld.dsp:
  Auto merged
client/mysql.cc:
  Auto merged
client/mysqlbinlog.cc:
  Auto merged
client/mysqltest.c:
  Auto merged
include/config-netware.h:
  Auto merged
include/my_base.h:
  Auto merged
include/my_global.h:
  Auto merged
include/my_sys.h:
  Auto merged
include/mysql_com.h:
  Auto merged
include/sql_state.h:
  Auto merged
innobase/include/row0mysql.h:
  Auto merged
innobase/row/row0sel.c:
  Auto merged
libmysql/libmysql.c:
  Auto merged
libmysqld/lib_sql.cc:
  Auto merged
myisam/mi_check.c:
  Auto merged
mysql-test/r/bdb.result:
  Auto merged
mysql-test/r/connect.result:
  Auto merged
mysql-test/r/ctype_ucs.result:
  Auto merged
mysql-test/r/derived.result:
  Auto merged
mysql-test/r/func_group.result:
  Auto merged
mysql-test/r/func_like.result:
  Auto merged
mysql-test/r/func_sapdb.result:
  Auto merged
mysql-test/r/func_time.result:
  Auto merged
mysql-test/r/insert.result:
  Auto merged
mysql-test/r/insert_select.result:
  Auto merged
mysql-test/r/join_outer.result:
  Auto merged
mysql-test/r/key.result:
  Auto merged
mysql-test/r/multi_update.result:
  Auto merged
mysql-test/r/mysqldump.result:
  Auto merged
mysql-test/r/null.result:
  Auto merged
mysql-test/r/null_key.result:
  Auto merged
mysql-test/r/query_cache.result:
  Auto merged
mysql-test/r/rpl_rotate_logs.result:
  Auto merged
mysql-test/r/rpl_server_id1.result:
  Auto merged
mysql-test/r/rpl_until.result:
  Auto merged
mysql-test/r/select.result:
  Auto merged
mysql-test/r/show_check.result:
  Auto merged
mysql-test/r/subselect.result:
  Auto merged
mysql-test/r/system_mysql_db.result:
  Auto merged
mysql-test/r/union.result:
  Auto merged
mysql-test/r/variables.result:
  Auto merged
mysql-test/t/multi_update.test:
  Auto merged
mysql-test/t/mysqlbinlog.test:
  Auto merged
mysql-test/t/rpl000015.test:
  Auto merged
mysql-test/t/subselect.test:
  Auto merged
mysql-test/t/variables.test:
  Auto merged
mysys/mf_iocache2.c:
  Auto merged
mysys/my_bitmap.c:
  Auto merged
mysys/my_pthread.c:
  Auto merged
netware/Makefile.am:
  Auto merged
netware/my_manage.c:
  Auto merged
netware/mysql_test_run.c:
  Auto merged
netware/BUILD/compile-linux-tools:
  Auto merged
netware/BUILD/compile-netware-standard:
  Auto merged
netware/BUILD/mwenv:
  Auto merged
netware/BUILD/nwbootstrap:
  Auto merged
scripts/make_binary_distribution.sh:
  Auto merged
scripts/mysql_install_db.sh:
  Auto merged
sql/ha_berkeley.cc:
  Auto merged
sql/ha_berkeley.h:
  Auto merged
sql/ha_heap.h:
  Auto merged
sql/item.cc:
  Auto merged
sql/item.h:
  Auto merged
sql/item_cmpfunc.cc:
  Auto merged
sql/item_cmpfunc.h:
  Auto merged
sql/item_create.cc:
  Auto merged
sql/item_create.h:
  Auto merged
sql/item_func.h:
  Auto merged
sql/item_subselect.cc:
  Auto merged
sql/item_sum.cc:
  Auto merged
sql/item_sum.h:
  Auto merged
sql/item_timefunc.h:
  Auto merged
sql/lex.h:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/net_serv.cc:
  Auto merged
sql/protocol.cc:
  Auto merged
sql/protocol.h:
  Auto merged
sql/records.cc:
  Auto merged
sql/repl_failsafe.cc:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/sql_acl.cc:
  Auto merged
sql/sql_acl.h:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_cache.cc:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_derived.cc:
  Auto merged
sql/sql_load.cc:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/sql_string.cc:
  Auto merged
sql/sql_update.cc:
  Auto merged
sql/structs.h:
  Auto merged
sql-common/client.c:
  Auto merged
configure.in:
  Merge with 4.1
include/mysqld_error.h:
  New errors from 4.1
libmysqld/Makefile.am:
  Merge with 4.1
myisam/myisamchk.c:
  Merge with 4.1
myisam/myisamdef.h:
  Merge with 4.1
myisam/sort.c:
  Merge with 4.1
mysql-test/r/mysqlbinlog.result:
  Merge with 4.1
mysql-test/r/range.result:
  Merge with 4.1
mysql-test/r/rpl_flush_log_loop.result:
  Merge with 4.1
mysql-test/r/rpl_replicate_do.result:
  Merge with 4.1
mysql-test/r/rpl_temporary.result:
  Merge with 4.1
mysql-test/r/rpl_user_variables.result:
  Merge with 4.1
mysql-test/t/func_time.test:
  Merge with 4.1
scripts/mysql_create_system_tables.sh:
  Merge with 4.1
scripts/mysql_fix_privilege_tables.sql:
  Merge with 4.1
sql/Makefile.am:
  Merge with 4.1
sql/filesort.cc:
  Merge with 4.1
sql/ha_innodb.cc:
  Merge with 4.1
sql/ha_innodb.h:
  Merge with 4.1
sql/ha_myisam.cc:
  Merge with 4.1
sql/handler.cc:
  Merge with 4.1
sql/handler.h:
  Merge with 4.1
sql/item_func.cc:
  Merge with 4.1
sql/item_timefunc.cc:
  Merge with 4.1
sql/log.cc:
  Merge with 4.1
sql/log_event.cc:
  Merge with 4.1
sql/mysqld.cc:
  Merge with 4.1
sql/opt_range.cc:
  Merge with 4.1
sql/opt_range.h:
  Merge with 4.1
sql/share/czech/errmsg.txt:
  Merge with 4.1
  Updated english error messages
sql/share/danish/errmsg.txt:
  Merge with 4.1
sql/share/dutch/errmsg.txt:
  Merge with 4.1
sql/share/english/errmsg.txt:
  Merge with 4.1
sql/share/estonian/errmsg.txt:
  Merge with 4.1
sql/share/french/errmsg.txt:
  Merge with 4.1
sql/share/german/errmsg.txt:
  Merge with 4.1
sql/share/greek/errmsg.txt:
  Merge with 4.1
sql/share/hungarian/errmsg.txt:
  Merge with 4.1
sql/share/italian/errmsg.txt:
  Merge with 4.1
sql/share/japanese/errmsg.txt:
  Merge with 4.1
sql/share/korean/errmsg.txt:
  Merge with 4.1
sql/share/norwegian-ny/errmsg.txt:
  Merge with 4.1
sql/share/norwegian/errmsg.txt:
  Merge with 4.1
sql/share/polish/errmsg.txt:
  Merge with 4.1
sql/share/portuguese/errmsg.txt:
  Merge with 4.1
sql/share/romanian/errmsg.txt:
  Merge with 4.1
sql/share/russian/errmsg.txt:
  Merge with 4.1
sql/share/serbian/errmsg.txt:
  Merge with 4.1
sql/share/slovak/errmsg.txt:
  Merge with 4.1
sql/share/spanish/errmsg.txt:
  Merge with 4.1
sql/share/swedish/errmsg.txt:
  Merge with 4.1
sql/share/ukrainian/errmsg.txt:
  Merge with 4.1
sql/slave.cc:
  Merge with 4.1
sql/sql_class.cc:
  Merge with 4.1
sql/sql_class.h:
  Merge with 4.1
sql/sql_db.cc:
  Merge with 4.1
sql/sql_insert.cc:
  Merge with 4.1
sql/sql_lex.cc:
  Merge with 4.1
sql/sql_lex.h:
  Merge with 4.1
sql/sql_parse.cc:
  Merge with 4.1 tree
  Changed // comments to /* */
sql/sql_prepare.cc:
  Merge with 4.1
sql/sql_select.cc:
  Merge with 4.1
sql/sql_table.cc:
  Merge with 4.1
sql/sql_yacc.yy:
  Merge with 4.1
sql/table.h:
  Merge with 4.1
tests/client_test.c:
  Merge with 4.1

30 files changed, 568 insertions, 331 deletions

diff --git a/myisam/ft_boolean_search.c b/myisam/ft_boolean_search.c
index 5f88122e730..196cb5c21fb 100644
--- a/myisam/ft_boolean_search.c
+++ b/myisam/ft_boolean_search.c
@@ -53,10 +53,11 @@ static double _nwghts[11]=
  -3.796875000000000};
 static double *nwghts=_nwghts+5; /* nwghts[i] = -0.5*1.5**i */
 
-#define FTB_FLAG_TRUNC 1                  /* MUST be 1                  */
-#define FTB_FLAG_YES   2                  /*  no two from these three   */
-#define FTB_FLAG_NO    4                  /*   YES, NO, WONLY           */
-#define FTB_FLAG_WONLY 8                  /*  should be ever set both   */
+#define FTB_FLAG_TRUNC 1
+/* At most one of the following flags can be set */
+#define FTB_FLAG_YES   2
+#define FTB_FLAG_NO    4
+#define FTB_FLAG_WONLY 8
 
 typedef struct st_ftb_expr FTB_EXPR;
 struct st_ftb_expr
@@ -157,6 +158,7 @@ static void _ftb_parse_query(FTB *ftb, byte **start, byte *end,
                                      w.len+extra));
         ftbw->len=w.len+1;
         ftbw->flags=0;
+        ftbw->off=0;
         if (param.yesno>0) ftbw->flags|=FTB_FLAG_YES;
         if (param.yesno<0) ftbw->flags|=FTB_FLAG_NO;
         if (param.trunc)   ftbw->flags|=FTB_FLAG_TRUNC;
@@ -203,23 +205,26 @@ static int _ftb_no_dupes_cmp(void* not_used __attribute__((unused)),
 static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
 {
   int r;
-  uint off;
   int subkeys=1;
   my_bool can_go_down;
   MI_INFO *info=ftb->info;
+  uint off, extra=HA_FT_WLEN+info->s->base.rec_reflength;
+  byte *lastkey_buf=ftbw->word+ftbw->off;
+
+  if (ftbw->flags & FTB_FLAG_TRUNC)
+    lastkey_buf+=ftbw->len;
 
   if (init_search)
   {
     ftbw->key_root=info->s->state.key_root[ftb->keynr];
     ftbw->keyinfo=info->s->keyinfo+ftb->keynr;
-    ftbw->off=0;
 
     r=_mi_search(info, ftbw->keyinfo, (uchar*) ftbw->word, ftbw->len,
                  SEARCH_FIND | SEARCH_BIGGER, ftbw->key_root);
   }
   else
   {
-    r=_mi_search(info, ftbw->keyinfo, (uchar*) ftbw->word+ftbw->off,
+    r=_mi_search(info, ftbw->keyinfo, (uchar*) lastkey_buf,
                    USE_WHOLE_KEY, SEARCH_BIGGER, ftbw->key_root);
   }
 
@@ -230,7 +235,7 @@ static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
     if (can_go_down)
     {
       /* going down ? */
-      off=info->lastkey_length-HA_FT_WLEN-info->s->base.rec_reflength;
+      off=info->lastkey_length-extra;
       subkeys=ft_sintXkorr(info->lastkey+off);
     }
     if (subkeys<0 || info->lastpos < info->state->data_file_length)
@@ -243,11 +248,11 @@ static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
   if (!r && !ftbw->off)
   {
     r= mi_compare_text(ftb->charset,
-                       info->lastkey + (ftbw->flags & FTB_FLAG_TRUNC),
-                       ftbw->len     - (ftbw->flags & FTB_FLAG_TRUNC),
-              (uchar*) ftbw->word    + (ftbw->flags & FTB_FLAG_TRUNC),
-                       ftbw->len     - (ftbw->flags & FTB_FLAG_TRUNC),
-                       0,0);
+                       info->lastkey+1,
+                       info->lastkey_length-extra-1,
+              (uchar*) ftbw->word+1,
+                       ftbw->len-1,
+             (my_bool) (ftbw->flags & FTB_FLAG_TRUNC),0);
   }
 
   if (r) /* not found */
@@ -269,8 +274,7 @@ static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
     }
 
     /* going up to the first-level tree to continue search there */
-    _mi_dpointer(info, (uchar*) (ftbw->word+ftbw->off+HA_FT_WLEN),
-                 ftbw->key_root);
+    _mi_dpointer(info, (uchar*) (lastkey_buf+HA_FT_WLEN), ftbw->key_root);
     ftbw->key_root=info->s->state.key_root[ftb->keynr];
     ftbw->keyinfo=info->s->keyinfo+ftb->keynr;
     ftbw->off=0;
@@ -278,7 +282,10 @@ static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
   }
 
   /* matching key found */
-  memcpy(ftbw->word+ftbw->off, info->lastkey, info->lastkey_length);
+  memcpy(lastkey_buf, info->lastkey, info->lastkey_length);
+  if (lastkey_buf == ftbw->word)
+    ftbw->len=info->lastkey_length-extra;
+
   /* going down ? */
   if (subkeys<0)
   {
@@ -291,7 +298,7 @@ static int _ft2_search(FTB *ftb, FTB_WORD *ftbw, my_bool init_search)
     ftbw->keyinfo=& info->s->ft2_keyinfo;
     r=_mi_search_first(info, ftbw->keyinfo, ftbw->key_root);
     DBUG_ASSERT(r==0);  /* found something */
-    memcpy(ftbw->word+off, info->lastkey, info->lastkey_length);
+    memcpy(lastkey_buf+off, info->lastkey, info->lastkey_length);
   }
   ftbw->docid[0]=info->lastpos;
   return 0;
@@ -356,7 +363,7 @@ static void _ftb_init_index_search(FT_INFO *ftb)
       else
         reset_tree(& ftb->no_dupes);
     }
-
+     
     if (_ft2_search(ftb, ftbw, 1))
       return;
   }
@@ -421,7 +428,7 @@ err:
 }
 
 
-/* returns 1 if str0 ~= /\<str1\>/ */
+/* returns 1 if str0 ~= /\bstr1\b/ */
 static int _ftb_strstr(const byte *s0, const byte *e0,
                 const byte *s1, const byte *e1,
                 CHARSET_INFO *cs)
diff --git a/myisam/ftdefs.h b/myisam/ftdefs.h
index a97485ec021..e23bc3b75ac 100644
--- a/myisam/ftdefs.h
+++ b/myisam/ftdefs.h
@@ -22,7 +22,6 @@
 #include <m_ctype.h>
 #include <my_tree.h>
 #include <queues.h>
-#include <assert.h>
 
 #define true_word_char(s,X)	(my_isalnum(s,X) || (X)=='_')
 #define misc_word_char(X)	((X)=='\'')
diff --git a/myisam/mi_check.c b/myisam/mi_check.c
index ab58a36915e..2015bcc7ec0 100644
--- a/myisam/mi_check.c
+++ b/myisam/mi_check.c
@@ -142,6 +142,8 @@ int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag)
     empty=0;
     for (i= info->state->del ; i > 0L && next_link != HA_OFFSET_ERROR ; i--)
     {
+      if (*killed_ptr(param))
+        DBUG_RETURN(1);
       if (test_flag & T_VERBOSE)
 	printf(" %9s",llstr(next_link,buff));
       if (next_link >= info->state->data_file_length)
@@ -233,6 +235,8 @@ static int check_k_link(MI_CHECK *param, register MI_INFO *info, uint nr)
   records= (ha_rows) (info->state->key_file_length / block_size);
   while (next_link != HA_OFFSET_ERROR && records > 0)
   {
+    if (*killed_ptr(param))
+      DBUG_RETURN(1);
     if (param->testflag & T_VERBOSE)
       printf("%16s",llstr(next_link,llbuff));
     if (next_link > info->state->key_file_length ||
@@ -307,7 +311,7 @@ int chk_size(MI_CHECK *param, register MI_INFO *info)
 #endif
   if (skr != size)
   {
-    info->state->data_file_length=size;	/* Skipp other errors */
+    info->state->data_file_length=size;	/* Skip other errors */
     if (skr > size && skr != size + MEMMAP_EXTRA_MARGIN)
     {
       error=1;
@@ -592,6 +596,8 @@ static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
   }
   for ( ;; )
   {
+    if (*killed_ptr(param))
+      goto err;
     memcpy((char*) info->lastkey,(char*) key,key_length);
     info->lastkey_length=key_length;
     if (nod_flag)
@@ -782,6 +788,8 @@ int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend)
   bzero((char*) key_checksum, info->s->base.keys * sizeof(key_checksum[0]));
   while (pos < info->state->data_file_length)
   {
+    if (*killed_ptr(param))
+      goto err2;
     switch (info->s->data_file_type) {
     case STATIC_RECORD:
       if (my_b_read(&param->read_cache,(byte*) record,
@@ -3672,7 +3680,7 @@ int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename)
       if (param->language)
 	keyseg->language=param->language;	/* change language */
     }
-    keyseg++;					/* Skipp end pointer */
+    keyseg++;					/* Skip end pointer */
   }
 
   /* Copy the unique definitions and change them to point at the new key
diff --git a/myisam/mi_create.c b/myisam/mi_create.c
index 838d647ea56..683640630f6 100644
--- a/myisam/mi_create.c
+++ b/myisam/mi_create.c
@@ -242,6 +242,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
     key_length=pointer;
     if (keydef->flag & HA_SPATIAL)
     {
+#ifdef HAVE_SPATIAL
       /* BAR TODO to support 3D and more dimensions in the future */
       uint sp_segs=SPDIMS*2;
       keydef->flag=HA_SPATIAL;
@@ -270,6 +271,10 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
       key_length+=SPLEN*sp_segs;
       length++;                              /* At least one length byte */
       min_key_length_skip+=SPLEN*2*SPDIMS;
+#else
+      my_errno= HA_ERR_UNSUPPORTED;
+      goto err;
+#endif /*HAVE_SPATIAL*/
     }
     else
     if (keydef->flag & HA_FULLTEXT)
@@ -588,6 +593,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
     for (j=0 ; j < keydefs[i].keysegs-sp_segs ; j++)
       if (mi_keyseg_write(file, &keydefs[i].seg[j]))
        goto err;
+#ifdef HAVE_SPATIAL
     for (j=0 ; j < sp_segs ; j++)
     {
       HA_KEYSEG sseg;
@@ -603,6 +609,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
       if (mi_keyseg_write(file, &sseg))
         goto err;
     }
+#endif
   }
   /* Create extra keys for unique definitions */
   offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
diff --git a/myisam/mi_delete.c b/myisam/mi_delete.c
index 19cfc050ea1..3e8ff9db009 100644
--- a/myisam/mi_delete.c
+++ b/myisam/mi_delete.c
@@ -18,7 +18,6 @@
 
 #include "fulltext.h"
 #include "rt_index.h"
-#include <assert.h>
 
 static int d_search(MI_INFO *info,MI_KEYDEF *keyinfo,uint comp_flag,
                     uchar *key,uint key_length,my_off_t page,uchar *anc_buff);
@@ -266,6 +265,7 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       {
         keyinfo=&info->s->ft2_keyinfo;
         kpos-=keyinfo->keylength+nod_flag; /* we'll modify key entry 'in vivo' */
+        get_key_full_length_rdonly(off, key);
         key+=off;
         ret_value=_mi_ck_real_delete(info, &info->s->ft2_keyinfo,
             key, HA_FT_WLEN, &root);
@@ -816,7 +816,7 @@ static uint remove_key(MI_KEYDEF *keyinfo, uint nod_flag,
 	  if (!(*start & 128))
 	    prev_length=0;			/* prev key not packed */
 	  if (keyinfo->seg[0].flag & HA_NULL_PART)
-	    lastkey++;				/* Skipp null marker */
+	    lastkey++;				/* Skip null marker */
 	  get_key_length(lastkey_length,lastkey);
 	  if (!next_length)			/* Same key after */
 	  {
diff --git a/myisam/mi_dynrec.c b/myisam/mi_dynrec.c
index f64e774810d..0b8d3c97872 100644
--- a/myisam/mi_dynrec.c
+++ b/myisam/mi_dynrec.c
@@ -25,7 +25,6 @@
 */
 
 #include "myisamdef.h"
-#include <assert.h>
 
 /* Enough for comparing if number is zero */
 static char zero_string[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
diff --git a/myisam/mi_key.c b/myisam/mi_key.c
index 97af156e89a..d19a3130a86 100644
--- a/myisam/mi_key.c
+++ b/myisam/mi_key.c
@@ -19,7 +19,6 @@
 #include "myisamdef.h"
 #include "m_ctype.h"
 #include "sp_defs.h"
-#include <assert.h>
 #ifdef HAVE_IEEEFP_H
 #include <ieeefp.h>
 #endif
@@ -46,7 +45,11 @@ uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
     /* 
       TODO: nulls processing
     */
+#ifdef HAVE_SPATIAL
     return sp_make_key(info,keynr,key,record,filepos);
+#else
+    DBUG_ASSERT(0); /* mi_open should check that this never happens*/
+#endif
   }
 
   start=key;
@@ -217,7 +220,7 @@ uint _mi_pack_key(register MI_INFO *info, uint keynr, uchar *key, uchar *old,
       k_length-= 2+length;
       set_if_smaller(length,tmp_length);	/* Safety */
       store_key_length_inc(key,length);
-      old+=2;					/* Skipp length */
+      old+=2;					/* Skip length */
       memcpy((byte*) key, pos+2,(size_t) length);
       key+= length;
       continue;
diff --git a/myisam/mi_open.c b/myisam/mi_open.c
index 53cf87b24b4..562227d2f03 100644
--- a/myisam/mi_open.c
+++ b/myisam/mi_open.c
@@ -327,9 +327,14 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
 	}
 	if (share->keyinfo[i].flag & HA_SPATIAL)
 	{
+#ifdef HAVE_SPATIAL
 	  uint sp_segs=SPDIMS*2;
 	  share->keyinfo[i].seg=pos-sp_segs;
 	  share->keyinfo[i].keysegs--;
+#else
+	  my_errno=HA_ERR_UNSUPPORTED;
+	  goto err;
+#endif
 	}
         else if (share->keyinfo[i].flag & HA_FULLTEXT)
 	{
@@ -726,8 +731,12 @@ static void setup_key_functions(register MI_KEYDEF *keyinfo)
 {
   if (keyinfo->key_alg == HA_KEY_ALG_RTREE)
   {
+#ifdef HAVE_RTREE_KEYS
     keyinfo->ck_insert = rtree_insert;
     keyinfo->ck_delete = rtree_delete;
+#else
+    DBUG_ASSERT(0); /* mi_open should check it never happens */
+#endif
   }
   else
   {
diff --git a/myisam/mi_range.c b/myisam/mi_range.c
index db01ada16dd..1e0fd42334e 100644
--- a/myisam/mi_range.c
+++ b/myisam/mi_range.c
@@ -65,6 +65,7 @@ ha_rows mi_records_in_range(MI_INFO *info, int inx, key_range *min_key,
     rw_rdlock(&info->s->key_root_lock[inx]);
 
   switch(info->s->keyinfo[inx].key_alg){
+#ifdef HAVE_RTREE_KEYS
   case HA_KEY_ALG_RTREE:
   {
     uchar * key_buff;
@@ -79,6 +80,7 @@ ha_rows mi_records_in_range(MI_INFO *info, int inx, key_range *min_key,
     res= res ? res : 1;                       /* Don't return 0 */
     break;
   }
+#endif
   case HA_KEY_ALG_BTREE:
   default:
     start_pos= (min_key ?
diff --git a/myisam/mi_rkey.c b/myisam/mi_rkey.c
index ddfac0a39a2..12db00337ee 100644
--- a/myisam/mi_rkey.c
+++ b/myisam/mi_rkey.c
@@ -74,6 +74,7 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
     use_key_length=USE_WHOLE_KEY;
 
   switch (info->s->keyinfo[inx].key_alg) {
+#ifdef HAVE_RTREE_KEYS
   case HA_KEY_ALG_RTREE:
     if (rtree_find_first(info,inx,key_buff,use_key_length,nextflag) < 0)
     {
@@ -81,6 +82,7 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
       goto err;
     }
     break;
+#endif
   case HA_KEY_ALG_BTREE:
   default:
     if (!_mi_search(info, keyinfo, key_buff, use_key_length,
diff --git a/myisam/mi_rnext.c b/myisam/mi_rnext.c
index 6e6056f98d9..69bf5c8deae 100644
--- a/myisam/mi_rnext.c
+++ b/myisam/mi_rnext.c
@@ -45,9 +45,11 @@ int mi_rnext(MI_INFO *info, byte *buf, int inx)
   if (!flag)
   {
     switch(info->s->keyinfo[inx].key_alg){
+#ifdef HAVE_RTREE_KEYS
     case HA_KEY_ALG_RTREE:
       error=rtree_get_first(info,inx,info->lastkey_length);
       break;
+#endif
     case HA_KEY_ALG_BTREE:
     default:
       error=_mi_search_first(info,info->s->keyinfo+inx,
@@ -58,6 +60,7 @@ int mi_rnext(MI_INFO *info, byte *buf, int inx)
   else
   {
     switch (info->s->keyinfo[inx].key_alg) {
+#ifdef HAVE_RTREE_KEYS
     case HA_KEY_ALG_RTREE:
       /*
 	Note that rtree doesn't support that the table
@@ -66,7 +69,7 @@ int mi_rnext(MI_INFO *info, byte *buf, int inx)
       */
       error= rtree_get_next(info,inx,info->lastkey_length);
       break;
-
+#endif
     case HA_KEY_ALG_BTREE:
     default:
       if (!changed)
diff --git a/myisam/mi_rnext_same.c b/myisam/mi_rnext_same.c
index 19190a60246..1342718d6aa 100644
--- a/myisam/mi_rnext_same.c
+++ b/myisam/mi_rnext_same.c
@@ -43,6 +43,7 @@ int mi_rnext_same(MI_INFO *info, byte *buf)
     
   switch (keyinfo->key_alg)
   {
+#ifdef HAVE_RTREE_KEYS
     case HA_KEY_ALG_RTREE:
       if ((error=rtree_find_next(info,inx,
 				 myisam_read_vec[info->last_key_func])))
@@ -53,6 +54,7 @@ int mi_rnext_same(MI_INFO *info, byte *buf)
 	break;
       }
       break;
+#endif
     case HA_KEY_ALG_BTREE:
     default:
       memcpy(info->lastkey2,info->lastkey,info->last_rkey_length);
diff --git a/myisam/mi_search.c b/myisam/mi_search.c
index 1c4342ff39a..1b03acddbc1 100644
--- a/myisam/mi_search.c
+++ b/myisam/mi_search.c
@@ -18,7 +18,6 @@
 
 #include "fulltext.h"
 #include "m_ctype.h"
-#include <assert.h>
 
 static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
                                 uchar *key, uchar *keypos,
@@ -761,7 +760,7 @@ uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 	}
 	if (keyseg->flag & HA_NULL_PART)
 	{
-	  key++;				/* Skipp null marker*/
+	  key++;				/* Skip null marker*/
 	  start++;
 	}
 
@@ -1395,7 +1394,7 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
     if (prev_key && !*prev_key++)
       org_key=prev_key=0;                       /* Can't pack against prev */
     else if (org_key)
-      org_key++;                                /* Skipp NULL */
+      org_key++;                                /* Skip NULL */
   }
   else
     s_temp->store_not_null=0;
diff --git a/myisam/mi_static.c b/myisam/mi_static.c
index f7d008ffbb7..f41aeff8453 100644
--- a/myisam/mi_static.c
+++ b/myisam/mi_static.c
@@ -38,7 +38,7 @@ my_bool myisam_concurrent_insert=1;
 #else
 my_bool myisam_concurrent_insert=0;
 #endif
-my_off_t myisam_max_extra_temp_length= MI_MAX_TEMP_LENGTH;
+my_off_t myisam_max_extra_temp_length= (my_off_t)MI_MAX_TEMP_LENGTH;
 my_off_t myisam_max_temp_length= MAX_FILE_SIZE;
 ulong    myisam_bulk_insert_tree_size=8192*1024;
 ulong    myisam_data_pointer_size=4;
diff --git a/myisam/mi_unique.c b/myisam/mi_unique.c
index 38b4ed93311..ad685f4cbdc 100644
--- a/myisam/mi_unique.c
+++ b/myisam/mi_unique.c
@@ -69,7 +69,8 @@ my_bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, byte *record,
 ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *record)
 {
   const byte *pos, *end;
-  ha_checksum crc=0;
+  ha_checksum crc= 0;
+  ulong seed1=0, seed2= 4;
   HA_KEYSEG *keyseg;
 
   for (keyseg=def->seg ; keyseg < def->end ; keyseg++)
@@ -108,9 +109,10 @@ ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *record)
     end= pos+length;
     if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT)
     {
-      ulong nr=1, nr2=4;
-      keyseg->charset->coll->hash_sort(keyseg->charset,(const uchar*)pos,length,&nr, &nr2);
-      crc=nr;
+      keyseg->charset->coll->hash_sort(keyseg->charset,
+                                       (const uchar*) pos, length, &seed1,
+                                       &seed2);
+      crc^= seed1;
     }
     else
       while (pos != end)
diff --git a/myisam/mi_write.c b/myisam/mi_write.c
index c17f47fc1ae..dc596672a84 100644
--- a/myisam/mi_write.c
+++ b/myisam/mi_write.c
@@ -18,7 +18,6 @@
 
 #include "fulltext.h"
 #include "rt_index.h"
-#include <assert.h>
 
 #define MAX_POINTER_LENGTH 8
 
diff --git a/myisam/myisamchk.c b/myisam/myisamchk.c
index 545aadebae8..6dcfe2cfa21 100644
--- a/myisam/myisamchk.c
+++ b/myisam/myisamchk.c
@@ -362,13 +362,13 @@ static void usage(void)
                       this option is deprecated; you can set variables\n\
                       directly with '--variable-name=value'.\n\
   -t, --tmpdir=path   Path for temporary files. Multiple paths can be\n\
-                      specified, separated by "
-#if defined( __WIN__) || defined(OS2)
-   "semicolon (;)"
+                      specified, separated by ");
+#if defined( __WIN__) || defined(OS2) || defined(__NETWARE__)
+   puts("semicolon (;)");
 #else
-   "colon (:)"
+   puts("colon (:)");
 #endif
-                      ", they will be used\n\
+                      puts(", they will be used\n\
                       in a round-robin fashion.\n\
   -s, --silent	      Only print errors.  One can use two -s to make\n\
 		      myisamchk very silent.\n\
@@ -1389,7 +1389,7 @@ static void descript(MI_CHECK *param, register MI_INFO *info, my_string name)
       }
       if (buff[0] == ',')
 	strmov(buff,buff+2);
-      int2str((long) share->rec[field].length,length,10);
+      int10_to_str((long) share->rec[field].length,length,10);
       null_bit[0]=null_pos[0]=0;
       if (share->rec[field].null_bit)
       {
@@ -1685,7 +1685,17 @@ err:
   DBUG_RETURN(1);
 } /* sort_record_index */
 
-int *killed_ptr(void *thd)
+
+
+/*
+  Check if myisamchk was killed by a signal
+  This is overloaded by other programs that want to be able to abort
+  sorting
+*/
+
+static my_bool not_killed= 0;
+
+volatile int *killed_ptr(MI_CHECK *param)
 {
   return (int *)thd; /* always NULL */
 }
diff --git a/myisam/myisamlog.c b/myisam/myisamlog.c
index 82f6277ce25..6679510227e 100644
--- a/myisam/myisamlog.c
+++ b/myisam/myisamlog.c
@@ -145,7 +145,7 @@ static void get_options(register int *argc, register char ***argv)
       switch((option=*pos)) {
       case '#':
 	DBUG_PUSH (++pos);
-	pos=" ";				/* Skipp rest of arg */
+	pos=" ";				/* Skip rest of arg */
 	break;
       case 'c':
 	if (! *++pos)
diff --git a/myisam/rt_index.c b/myisam/rt_index.c
index 30146b9fd67..4fffd848624 100644
--- a/myisam/rt_index.c
+++ b/myisam/rt_index.c
@@ -17,11 +17,15 @@
 
 #include "myisamdef.h"
 
+#ifdef HAVE_RTREE_KEYS
+
 #include "rt_index.h"
 #include "rt_key.h"
 #include "rt_mbr.h"
 
 #define REINSERT_BUFFER_INC 10
+#define PICK_BY_AREA
+/*#define PICK_BY_PERIMETER*/
 
 typedef struct st_page_level
 {
@@ -437,6 +441,84 @@ int rtree_get_next(MI_INFO *info, uint keynr, uint key_length)
 
 
 /*
+  Choose non-leaf better key for insertion
+*/
+
+#ifdef PICK_BY_PERIMETER
+static uchar *rtree_pick_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
+			     uint key_length, uchar *page_buf, uint nod_flag)
+{
+  double increase;
+  double best_incr = DBL_MAX;
+  double perimeter;
+  double best_perimeter;
+  uchar *best_key;
+  uchar *k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
+  uchar *last = rt_PAGE_END(page_buf);
+
+  LINT_INIT(best_perimeter);
+  LINT_INIT(best_key);
+
+  for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
+  {
+    if ((increase = rtree_perimeter_increase(keyinfo->seg, k, key, key_length,
+					     &perimeter)) == -1)
+      return NULL;
+    if ((increase < best_incr)||
+	(increase == best_incr && perimeter < best_perimeter))
+    {
+      best_key = k;
+      best_perimeter= perimeter;
+      best_incr = increase;
+    }
+  }
+  return best_key;
+}
+
+#endif /*PICK_BY_PERIMETER*/
+
+#ifdef PICK_BY_AREA
+static uchar *rtree_pick_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
+			     uint key_length, uchar *page_buf, uint nod_flag)
+{
+  double increase;
+  double best_incr = DBL_MAX;
+  double area;
+  double best_area;
+  uchar *best_key;
+  uchar *k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
+  uchar *last = rt_PAGE_END(page_buf);
+
+  LINT_INIT(best_area);
+  LINT_INIT(best_key);
+
+  for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
+  {
+    if ((increase = rtree_area_increase(keyinfo->seg, k, key, key_length, 
+                                        &area)) == -1)
+      return NULL;
+    if (increase < best_incr)
+    {
+      best_key = k;
+      best_area = area;
+      best_incr = increase;
+    }
+    else
+    {
+      if ((increase == best_incr) && (area < best_area))
+      {
+        best_key = k;
+        best_area = area;
+        best_incr = increase;
+      }
+    }
+  }
+  return best_key;
+}
+
+#endif /*PICK_BY_AREA*/
+
+/*
   Go down and insert key into tree
 
   RETURN
@@ -467,7 +549,7 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   if ((ins_level == -1 && nod_flag) ||       /* key: go down to leaf */
       (ins_level > -1 && ins_level > level)) /* branch: go down to ins_level */
   { 
-    if ((k = rtree_choose_key(info, keyinfo, key, key_length, page_buf, 
+    if ((k = rtree_pick_key(info, keyinfo, key, key_length, page_buf, 
                              nod_flag)) == NULL)
       goto err1;
     switch ((res = rtree_insert_req(info, keyinfo, key, key_length, 
@@ -577,7 +659,7 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
 
       mi_putint(new_root_buf, 2, nod_flag);
       if ((new_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) ==
-                                                             HA_OFFSET_ERROR)
+	  HA_OFFSET_ERROR)
         goto err1;
 
       new_key = new_root_buf + keyinfo->block_length + nod_flag;
@@ -991,3 +1073,6 @@ err1:
   my_afree((byte*)page_buf);
   return HA_POS_ERROR;
 }
+
+#endif /*HAVE_RTREE_KEYS*/
+
diff --git a/myisam/rt_index.h b/myisam/rt_index.h
index 1a0fce72a82..d3fcd934719 100644
--- a/myisam/rt_index.h
+++ b/myisam/rt_index.h
@@ -18,12 +18,14 @@
 #ifndef _rt_index_h
 #define _rt_index_h
 
+#ifdef HAVE_RTREE_KEYS
+
 #define rt_PAGE_FIRST_KEY(page, nod_flag) (page + 2 + nod_flag)
 #define rt_PAGE_NEXT_KEY(key, key_length, nod_flag) (key + key_length + \
               (nod_flag ? nod_flag : info->s->base.rec_reflength))
 #define rt_PAGE_END(page) (page + mi_getint(page))
 
-#define rt_PAGE_MIN_SIZE(block_length) ((uint)(block_length) / 2)
+#define rt_PAGE_MIN_SIZE(block_length) ((uint)(block_length) / 3)
 
 int rtree_insert(MI_INFO *info, uint keynr, uchar *key, uint key_length);
 int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length);
@@ -41,4 +43,5 @@ ha_rows rtree_estimate(MI_INFO *info, uint keynr, uchar *key,
 int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key, 
                     uint key_length, my_off_t *new_page_offs);
 
+#endif /*HAVE_RTREE_KEYS*/
 #endif /* _rt_index_h */
diff --git a/myisam/rt_key.c b/myisam/rt_key.c
index f18d13af8d8..e2a402fbefd 100644
--- a/myisam/rt_key.c
+++ b/myisam/rt_key.c
@@ -16,6 +16,7 @@
 
 #include "myisamdef.h"
 
+#ifdef HAVE_RTREE_KEYS
 #include "rt_index.h"
 #include "rt_key.h"
 #include "rt_mbr.h"
@@ -35,7 +36,8 @@ int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   uint page_size = mi_getint(page_buf);
   uint nod_flag = mi_test_if_nod(page_buf);
 
-  if (page_size + key_length + nod_flag <= keyinfo->block_length)  
+  if (page_size + key_length + info->s->base.rec_reflength <=
+      keyinfo->block_length)
   {
     /* split won't be necessary */
     if (nod_flag)
@@ -95,45 +97,4 @@ int rtree_set_key_mbr(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   return rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length);
 }
 
-
-/*
-  Choose non-leaf better key for insertion
-*/
-
-uchar *rtree_choose_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
-			uint key_length, uchar *page_buf, uint nod_flag)
-{
-  double increase;
-  double best_incr = DBL_MAX;
-  double area;
-  double best_area;
-  uchar *best_key;
-  uchar *k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
-  uchar *last = rt_PAGE_END(page_buf);
-
-  LINT_INIT(best_area);
-  LINT_INIT(best_key);
-
-  for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
-  {
-    if ((increase = rtree_area_increase(keyinfo->seg, key, k, key_length, 
-                                        &area)) == -1)
-      return NULL;
-    if (increase < best_incr)
-    {
-      best_key = k;
-      best_area = area;
-      best_incr = increase;
-    }
-    else
-    {
-      if ((increase == best_incr) && (area < best_area))
-      {
-        best_key = k;
-        best_area = area;
-        best_incr = increase;
-      }
-    }
-  }
-  return best_key;
-}
+#endif /*HAVE_RTREE_KEYS*/
diff --git a/myisam/rt_key.h b/myisam/rt_key.h
index dfd7b874b54..df4f8aa03a2 100644
--- a/myisam/rt_key.h
+++ b/myisam/rt_key.h
@@ -20,12 +20,14 @@
 #ifndef _rt_key_h
 #define _rt_key_h
 
+#ifdef HAVE_RTREE_KEYS
+
 int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
                  uint key_length, uchar *page_buf, my_off_t *new_page);
 int rtree_delete_key(MI_INFO *info, uchar *page, uchar *key, 
                     uint key_length, uint nod_flag);
 int rtree_set_key_mbr(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
                     uint key_length, my_off_t child_page);
-uchar *rtree_choose_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
-                       uint key_length, uchar *page_buf, uint nod_flag);
+
+#endif /*HAVE_RTREE_KEYS*/
 #endif /* _rt_key_h */
diff --git a/myisam/rt_mbr.c b/myisam/rt_mbr.c
index bb13c0769b3..7b556979904 100644
--- a/myisam/rt_mbr.c
+++ b/myisam/rt_mbr.c
@@ -17,6 +17,8 @@
 
 #include "myisamdef.h"
 
+#ifdef HAVE_RTREE_KEYS
+
 #include "rt_index.h"
 #include "rt_mbr.h"
 
@@ -24,7 +26,7 @@
 #define CONTAIN_CMP(amin, amax, bmin, bmax) ((bmin > amin)  || (bmax <  amax))
 #define WITHIN_CMP(amin, amax, bmin, bmax) ((amin > bmin)  || (amax <  bmax))
 #define DISJOINT_CMP(amin, amax, bmin, bmax) ((amin <= bmax) && (bmin <= amax))
-#define EQUAL_CMP(amix, amax, bmin, bmax) ((amix != bmin) || (amax != bmax))
+#define EQUAL_CMP(amin, amax, bmin, bmax) ((amin != bmin) || (amax != bmax))
 
 #define FCMP(A, B) ((int)(A) - (int)(B))
 #define p_inc(A, B, X)  {A += X; B += X;}
@@ -61,12 +63,9 @@
   type amin, amax, bmin, bmax; \
   amin = korr_func(a); \
   bmin = korr_func(b); \
-  p_inc(a, b, len); \
-  amax = korr_func(a); \
-  bmax = korr_func(b); \
+  amax = korr_func(a+len); \
+  bmax = korr_func(b+len); \
   RT_CMP(nextflag); \
-  p_inc(a, b, len); \
-  break; \
 }
 
 #define RT_CMP_GET(type, get_func, len, nextflag) \
@@ -74,12 +73,9 @@
   type amin, amax, bmin, bmax; \
   get_func(amin, a); \
   get_func(bmin, b); \
-  p_inc(a, b, len); \
-  get_func(amax, a); \
-  get_func(bmax, b); \
+  get_func(amax, a+len); \
+  get_func(bmax, b+len); \
   RT_CMP(nextflag); \
-  p_inc(a, b, len); \
-  break; \
 }
 
 /*
@@ -98,54 +94,55 @@ int rtree_key_cmp(HA_KEYSEG *keyseg, uchar *b, uchar *a, uint key_length,
 {
   for (; (int) key_length > 0; keyseg += 2 )
   {
-    key_length -= keyseg->length * 2;
-
+    uint32 keyseg_length;
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_CMP_KORR(int8, mi_sint1korr, 1, nextflag);
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_CMP_KORR(uint8, mi_uint1korr, 1, nextflag);
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin,amax,bmin,bmax;
-        amin = (int)*((signed char *)a);
-        bmin = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amax = (int)*((signed char *)a);
-        bmax = (int)*((signed char *)b);
-        RT_CMP(nextflag);
-        p_inc(a, b, 1);
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_CMP_KORR(int16, mi_sint2korr, 2, nextflag);
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_CMP_KORR(uint16, mi_uint2korr, 2, nextflag);
+      break;
     case HA_KEYTYPE_INT24:
       RT_CMP_KORR(int32, mi_sint3korr, 3, nextflag);
+      break;
     case HA_KEYTYPE_UINT24:
       RT_CMP_KORR(uint32, mi_uint3korr, 3, nextflag);
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_CMP_KORR(int32, mi_sint4korr, 4, nextflag);
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_CMP_KORR(uint32, mi_uint4korr, 4, nextflag);
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_CMP_KORR(longlong, mi_sint8korr, 8, nextflag)
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_CMP_KORR(ulonglong, mi_uint8korr, 8, nextflag)
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_CMP_GET(float, mi_float4get, 4, nextflag);
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_CMP_GET(double, mi_float8get, 8, nextflag);
+      break;
     case HA_KEYTYPE_END:
       goto end;
+    default:
+      return 1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
+    b+= keyseg_length;
   }
 
 end:
@@ -165,22 +162,16 @@ end:
 { \
   type amin, amax; \
   amin = korr_func(a); \
-  a += len; \
-  amax = korr_func(a); \
-  a += len; \
+  amax = korr_func(a+len); \
   res *= (cast(amax) - cast(amin)); \
-  break; \
 }
 
 #define RT_VOL_GET(type, get_func, len, cast) \
 { \
   type amin, amax; \
   get_func(amin, a); \
-  a += len; \
-  get_func(amax, a); \
-  a += len; \
+  get_func(amax, a+len); \
   res *= (cast(amax) - cast(amin)); \
-  break; \
 }
 
 /*
@@ -191,53 +182,55 @@ double rtree_rect_volume(HA_KEYSEG *keyseg, uchar *a, uint key_length)
   double res = 1;
   for (; (int)key_length > 0; keyseg += 2)
   {
-    key_length -= keyseg->length * 2;
-    
+    uint32 keyseg_length;
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_VOL_KORR(int8, mi_sint1korr, 1, (double));
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_VOL_KORR(uint8, mi_uint1korr, 1, (double));
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax;
-        amin = (int)*((signed char *)a);
-        a += 1;
-        amax = (int)*((signed char *)a);
-        a += 1;
-        res *= ((double)amax - (double)amin);
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_VOL_KORR(int16, mi_sint2korr, 2, (double));
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_VOL_KORR(uint16, mi_uint2korr, 2, (double));
+      break;
     case HA_KEYTYPE_INT24:
       RT_VOL_KORR(int32, mi_sint3korr, 3, (double));
+      break;
     case HA_KEYTYPE_UINT24:
       RT_VOL_KORR(uint32, mi_uint3korr, 3, (double));
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_VOL_KORR(int32, mi_sint4korr, 4, (double));
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_VOL_KORR(uint32, mi_uint4korr, 4, (double));
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_VOL_KORR(longlong, mi_sint8korr, 8, (double));
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_VOL_KORR(longlong, mi_sint8korr, 8, ulonglong2double);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_VOL_GET(float, mi_float4get, 4, (double));
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_VOL_GET(double, mi_float8get, 8, (double));
+      break;
     case HA_KEYTYPE_END:
       key_length = 0;
       break;
+    default:
+      return -1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
   }
   return res;
 }
@@ -246,81 +239,78 @@ double rtree_rect_volume(HA_KEYSEG *keyseg, uchar *a, uint key_length)
 { \
   type amin, amax; \
   amin = korr_func(a); \
-  a += len; \
-  amax = korr_func(a); \
-  a += len; \
+  amax = korr_func(a+len); \
   *res++ = cast(amin); \
   *res++ = cast(amax); \
-  break; \
 }
 
 #define RT_D_MBR_GET(type, get_func, len, cast) \
 { \
   type amin, amax; \
   get_func(amin, a); \
-  a += len; \
-  get_func(amax, a); \
-  a += len; \
+  get_func(amax, a+len); \
   *res++ = cast(amin); \
   *res++ = cast(amax); \
-  break; \
 }
 
+
 /*
- Creates an MBR as an array of doubles.
+  Creates an MBR as an array of doubles.
 */
+
 int rtree_d_mbr(HA_KEYSEG *keyseg, uchar *a, uint key_length, double *res)
 {
   for (; (int)key_length > 0; keyseg += 2)
   {
-    key_length -= keyseg->length * 2;
-    
+    uint32 keyseg_length;
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_D_MBR_KORR(int8, mi_sint1korr, 1, (double));
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_D_MBR_KORR(uint8, mi_uint1korr, 1, (double));
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax;
-        amin = (int)*((signed char *)a);
-        a += 1;
-        amax = (int)*((signed char *)a);
-        a += 1;
-        *res++ = (double)amin;
-        *res++ = (double)amax;
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_D_MBR_KORR(int16, mi_sint2korr, 2, (double));
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_D_MBR_KORR(uint16, mi_uint2korr, 2, (double));
+      break;
     case HA_KEYTYPE_INT24:
       RT_D_MBR_KORR(int32, mi_sint3korr, 3, (double));
+      break;
     case HA_KEYTYPE_UINT24:
       RT_D_MBR_KORR(uint32, mi_uint3korr, 3, (double));
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_D_MBR_KORR(int32, mi_sint4korr, 4, (double));
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_D_MBR_KORR(uint32, mi_uint4korr, 4, (double));
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_D_MBR_KORR(longlong, mi_sint8korr, 8, (double));
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_D_MBR_KORR(longlong, mi_sint8korr, 8, ulonglong2double);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_D_MBR_GET(float, mi_float4get, 4, (double));
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_D_MBR_GET(double, mi_float8get, 8, (double));
+      break;
     case HA_KEYTYPE_END:
       key_length = 0;
       break;
+    default:
+      return 1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
   }
   return 0;
 }
@@ -330,17 +320,12 @@ int rtree_d_mbr(HA_KEYSEG *keyseg, uchar *a, uint key_length, double *res)
   type amin, amax, bmin, bmax; \
   amin = korr_func(a); \
   bmin = korr_func(b); \
-  p_inc(a, b, len); \
-  amax = korr_func(a); \
-  bmax = korr_func(b); \
-  p_inc(a, b, len); \
+  amax = korr_func(a+len); \
+  bmax = korr_func(b+len); \
   amin = min(amin, bmin); \
   amax = max(amax, bmax); \
   store_func(c, amin); \
-  c += len; \
-  store_func(c, amax); \
-  c += len; \
-  break; \
+  store_func(c+len, amax); \
 }
 
 #define RT_COMB_GET(type, get_func, store_func, len) \
@@ -348,17 +333,12 @@ int rtree_d_mbr(HA_KEYSEG *keyseg, uchar *a, uint key_length, double *res)
   type amin, amax, bmin, bmax; \
   get_func(amin, a); \
   get_func(bmin, b); \
-  p_inc(a, b, len); \
-  get_func(amax, a); \
-  get_func(bmax, b); \
-  p_inc(a, b, len); \
+  get_func(amax, a+len); \
+  get_func(bmax, b+len); \
   amin = min(amin, bmin); \
   amax = max(amax, bmax); \
   store_func(c, amin); \
-  c += len; \
-  store_func(c, amax); \
-  c += len; \
-  break; \
+  store_func(c+len, amax); \
 }
 
 /*
@@ -370,81 +350,75 @@ int rtree_d_mbr(HA_KEYSEG *keyseg, uchar *a, uint key_length, double *res)
 int rtree_combine_rect(HA_KEYSEG *keyseg, uchar* a, uchar* b, uchar* c, 
 		       uint key_length)
 {
-
   for ( ; (int) key_length > 0 ; keyseg += 2)
   {
-    key_length -= keyseg->length * 2;
-    
+    uint32 keyseg_length;
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_COMB_KORR(int8, mi_sint1korr, mi_int1store, 1);
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_COMB_KORR(uint8, mi_uint1korr, mi_int1store, 1);
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax, bmin, bmax;
-        amin = (int)*((signed char *)a);
-        bmin = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amax = (int)*((signed char *)a);
-        bmax = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amin = min(amin, bmin);
-        amax = max(amax, bmax);
-        *((signed char*)c) = amin;
-        c += 1;
-        *((signed char*)c) = amax;
-        c += 1;
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_COMB_KORR(int16, mi_sint2korr, mi_int2store, 2);
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_COMB_KORR(uint16, mi_uint2korr, mi_int2store, 2);
+      break;
     case HA_KEYTYPE_INT24:
       RT_COMB_KORR(int32, mi_sint3korr, mi_int3store, 3);
+      break;
     case HA_KEYTYPE_UINT24:
       RT_COMB_KORR(uint32, mi_uint3korr, mi_int3store, 3);
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_COMB_KORR(int32, mi_sint4korr, mi_int4store, 4);
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_COMB_KORR(uint32, mi_uint4korr, mi_int4store, 4);
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_COMB_KORR(longlong, mi_sint8korr, mi_int8store, 8);
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_COMB_KORR(ulonglong, mi_uint8korr, mi_int8store, 8);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_COMB_GET(float, mi_float4get, mi_float4store, 4);
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_COMB_GET(double, mi_float8get, mi_float8store, 8);
+      break;
     case HA_KEYTYPE_END:
       return 0;
+    default:
+      return 1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
+    b+= keyseg_length;
+    c+= keyseg_length;
   }
   return 0;
 }
 
+
 #define RT_OVL_AREA_KORR(type, korr_func, len) \
 { \
   type amin, amax, bmin, bmax; \
   amin = korr_func(a); \
   bmin = korr_func(b); \
-  p_inc(a, b, len); \
-  amax = korr_func(a); \
-  bmax = korr_func(b); \
-  p_inc(a, b, len); \
+  amax = korr_func(a+len); \
+  bmax = korr_func(b+len); \
   amin = max(amin, bmin); \
   amax = min(amax, bmax); \
   if (amin >= amax) \
     return 0; \
   res *= amax - amin; \
-  break; \
 }
 
 #define RT_OVL_AREA_GET(type, get_func, len) \
@@ -452,16 +426,13 @@ int rtree_combine_rect(HA_KEYSEG *keyseg, uchar* a, uchar* b, uchar* c,
   type amin, amax, bmin, bmax; \
   get_func(amin, a); \
   get_func(bmin, b); \
-  p_inc(a, b, len); \
-  get_func(amax, a); \
-  get_func(bmax, b); \
-  p_inc(a, b, len); \
+  get_func(amax, a+len); \
+  get_func(bmax, b+len); \
   amin = max(amin, bmin); \
   amax = min(amax, bmax); \
   if (amin >= amax)  \
     return 0; \
   res *= amax - amin; \
-  break; \
 }
 
 /*
@@ -473,58 +444,55 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
   double res = 1;
   for (; (int) key_length > 0 ; keyseg += 2)
   {
-    key_length -= keyseg->length * 2;
-    
+    uint32 keyseg_length;
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_OVL_AREA_KORR(int8, mi_sint1korr, 1);
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return -1;
+      RT_OVL_AREA_KORR(uint8, mi_uint1korr, 1);
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax, bmin, bmax;
-        amin = (int)*((signed char *)a);
-        bmin = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amax = (int)*((signed char *)a);
-        bmax = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amin = max(amin, bmin);
-        amax = min(amax, bmax);
-        if (amin >= amax) 
-          return 0;
-        res *= amax - amin;
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_OVL_AREA_KORR(int16, mi_sint2korr, 2);
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_OVL_AREA_KORR(uint16, mi_uint2korr, 2);
+      break;
     case HA_KEYTYPE_INT24:
       RT_OVL_AREA_KORR(int32, mi_sint3korr, 3);
+      break;
     case HA_KEYTYPE_UINT24:
       RT_OVL_AREA_KORR(uint32, mi_uint3korr, 3);
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_OVL_AREA_KORR(int32, mi_sint4korr, 4);
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_OVL_AREA_KORR(uint32, mi_uint4korr, 4);
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_OVL_AREA_GET(float, mi_float4get, 4);
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_OVL_AREA_GET(double, mi_float8get, 8);
+      break;
     case HA_KEYTYPE_END:
       return res;
+    default:
+      return -1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
+    b+= keyseg_length;
   }
   return res;
 }
@@ -534,13 +502,10 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
    type amin, amax, bmin, bmax; \
    amin = korr_func(a); \
    bmin = korr_func(b); \
-   p_inc(a, b, len); \
-   amax = korr_func(a); \
-   bmax = korr_func(b); \
-   p_inc(a, b, len); \
+   amax = korr_func(a+len); \
+   bmax = korr_func(b+len); \
    a_area *= (((double)amax) - ((double)amin)); \
    *ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
-   break; \
 }
 
 #define RT_AREA_INC_GET(type, get_func, len)\
@@ -548,13 +513,10 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
    type amin, amax, bmin, bmax; \
    get_func(amin, a); \
    get_func(bmin, b); \
-   p_inc(a, b, len); \
-   get_func(amax, a); \
-   get_func(bmax, b); \
-   p_inc(a, b, len); \
+   get_func(amax, a+len); \
+   get_func(bmax, b+len); \
    a_area *= (((double)amax) - ((double)amin)); \
    *ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
-   break; \
 }
 
 /*
@@ -563,70 +525,159 @@ Calculates MBR_AREA(a+b) - MBR_AREA(a)
 double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b, 
                           uint key_length, double *ab_area)
 {
-  double a_area = 1;
+  double a_area= 1.0;
   
-  *ab_area = 1;
+  *ab_area= 1.0;
   for (; (int)key_length > 0; keyseg += 2)
   {
-    key_length -= keyseg->length * 2;
-    
-    /* Handle NULL part */
-    if (keyseg->null_bit)
-    {
+    uint32 keyseg_length;
+
+    if (keyseg->null_bit)                       /* Handle NULL part */
       return -1;
-    }
 
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_AREA_INC_KORR(int8, mi_sint1korr, 1);
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_AREA_INC_KORR(uint8, mi_uint1korr, 1);
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax, bmin, bmax;
-        amin = (int)*((signed char *)a);
-        bmin = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        amax = (int)*((signed char *)a);
-        bmax = (int)*((signed char *)b);
-        p_inc(a, b, 1);
-        a_area *= (((double)amax) - ((double)amin));
-        *ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin));
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_AREA_INC_KORR(int16, mi_sint2korr, 2);
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_AREA_INC_KORR(uint16, mi_uint2korr, 2);
+      break;
     case HA_KEYTYPE_INT24:
       RT_AREA_INC_KORR(int32, mi_sint3korr, 3);
+      break;
     case HA_KEYTYPE_UINT24:
       RT_AREA_INC_KORR(int32, mi_uint3korr, 3);
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_AREA_INC_KORR(int32, mi_sint4korr, 4);
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_AREA_INC_KORR(uint32, mi_uint4korr, 4);
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_AREA_INC_KORR(longlong, mi_sint8korr, 8);
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_AREA_INC_KORR(longlong, mi_sint8korr, 8);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_AREA_INC_GET(float, mi_float4get, 4);
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_AREA_INC_GET(double, mi_float8get, 8);
+      break;
     case HA_KEYTYPE_END:
       return *ab_area - a_area;
+    default:
+      return -1;
     }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
+    b+= keyseg_length;
   }
   return *ab_area - a_area;
 }
 
+#define RT_PERIM_INC_KORR(type, korr_func, len) \
+{ \
+   type amin, amax, bmin, bmax; \
+   amin = korr_func(a); \
+   bmin = korr_func(b); \
+   amax = korr_func(a+len); \
+   bmax = korr_func(b+len); \
+   a_perim+= (((double)amax) - ((double)amin)); \
+   *ab_perim+= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+}
+
+#define RT_PERIM_INC_GET(type, get_func, len)\
+{\
+   type amin, amax, bmin, bmax; \
+   get_func(amin, a); \
+   get_func(bmin, b); \
+   get_func(amax, a+len); \
+   get_func(bmax, b+len); \
+   a_perim+= (((double)amax) - ((double)amin)); \
+   *ab_perim+= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+}
+
+/*
+Calculates MBR_PERIMETER(a+b) - MBR_PERIMETER(a)
+*/
+double rtree_perimeter_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b, 
+				uint key_length, double *ab_perim)
+{
+  double a_perim = 0.0;
+  
+  *ab_perim= 0.0;
+  for (; (int)key_length > 0; keyseg += 2)
+  {
+    uint32 keyseg_length;
+
+    if (keyseg->null_bit)                       /* Handle NULL part */
+      return -1;
+
+    switch ((enum ha_base_keytype) keyseg->type) {
+    case HA_KEYTYPE_INT8:
+      RT_PERIM_INC_KORR(int8, mi_sint1korr, 1);
+      break;
+    case HA_KEYTYPE_BINARY:
+      RT_PERIM_INC_KORR(uint8, mi_uint1korr, 1);
+      break;
+    case HA_KEYTYPE_SHORT_INT:
+      RT_PERIM_INC_KORR(int16, mi_sint2korr, 2);
+      break;
+    case HA_KEYTYPE_USHORT_INT:
+      RT_PERIM_INC_KORR(uint16, mi_uint2korr, 2);
+      break;
+    case HA_KEYTYPE_INT24:
+      RT_PERIM_INC_KORR(int32, mi_sint3korr, 3);
+      break;
+    case HA_KEYTYPE_UINT24:
+      RT_PERIM_INC_KORR(int32, mi_uint3korr, 3);
+      break;
+    case HA_KEYTYPE_LONG_INT:
+      RT_PERIM_INC_KORR(int32, mi_sint4korr, 4);
+      break;
+    case HA_KEYTYPE_ULONG_INT:
+      RT_PERIM_INC_KORR(uint32, mi_uint4korr, 4);
+      break;
+#ifdef HAVE_LONG_LONG
+    case HA_KEYTYPE_LONGLONG:
+      RT_PERIM_INC_KORR(longlong, mi_sint8korr, 8);
+      break;
+    case HA_KEYTYPE_ULONGLONG:
+      RT_PERIM_INC_KORR(longlong, mi_sint8korr, 8);
+      break;
+#endif
+    case HA_KEYTYPE_FLOAT:
+      RT_PERIM_INC_GET(float, mi_float4get, 4);
+      break;
+    case HA_KEYTYPE_DOUBLE:
+      RT_PERIM_INC_GET(double, mi_float8get, 8);
+      break;
+    case HA_KEYTYPE_END:
+      return *ab_perim - a_perim;
+    default:
+      return -1;
+    }
+    keyseg_length= keyseg->length * 2;
+    key_length-= keyseg_length;
+    a+= keyseg_length;
+    b+= keyseg_length;
+  }
+  return *ab_perim - a_perim;
+}
+
+
 #define RT_PAGE_MBR_KORR(type, korr_func, store_func, len) \
 { \
   type amin, amax, bmin, bmax; \
@@ -647,7 +698,6 @@ double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
   store_func(c, amax); \
   c += len; \
   inc += 2 * len; \
-  break; \
 }
 
 #define RT_PAGE_MBR_GET(type, get_func, store_func, len) \
@@ -670,7 +720,6 @@ double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
   store_func(c, amax); \
   c += len; \
   inc += 2 * len; \
-  break; \
 }
 
 /*
@@ -698,62 +747,51 @@ int rtree_page_mbr(MI_INFO *info, HA_KEYSEG *keyseg, uchar *page_buf,
     k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
 
     switch ((enum ha_base_keytype) keyseg->type) {
-    case HA_KEYTYPE_TEXT:
+    case HA_KEYTYPE_INT8:
+      RT_PAGE_MBR_KORR(int8, mi_sint1korr, mi_int1store, 1);
+      break;
     case HA_KEYTYPE_BINARY:
-    case HA_KEYTYPE_VARTEXT:
-    case HA_KEYTYPE_VARBINARY:
-    case HA_KEYTYPE_NUM:
-    default:
-      return 1;
+      RT_PAGE_MBR_KORR(uint8, mi_uint1korr, mi_int1store, 1);
       break;
-    case HA_KEYTYPE_INT8:
-      {
-        int amin, amax, bmin, bmax;
-        amin = (int)*((signed char *)(k + inc));
-        amax = (int)*((signed char *)(k + inc + 1));
-        k = rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
-        for (; k < last; k = rt_PAGE_NEXT_KEY(k, k_len, nod_flag))
-        {
-          bmin = (int)*((signed char *)(k + inc));
-          bmax = (int)*((signed char *)(k + inc + 1));
-
-          if (amin > bmin)
-            amin = bmin;
-          if (amax < bmax)
-            amax = bmax;
-        }
-        *((signed char*)c) = amin;
-        c += 1;
-        *((signed char*)c) = amax;
-        c += 1;
-        inc += 1 * 2;
-        break;
-      }
     case HA_KEYTYPE_SHORT_INT:
       RT_PAGE_MBR_KORR(int16, mi_sint2korr, mi_int2store, 2);
+      break;
     case HA_KEYTYPE_USHORT_INT:
       RT_PAGE_MBR_KORR(uint16, mi_uint2korr, mi_int2store, 2);
+      break;
     case HA_KEYTYPE_INT24:
       RT_PAGE_MBR_KORR(int32, mi_sint3korr, mi_int3store, 3);
+      break;
     case HA_KEYTYPE_UINT24:
       RT_PAGE_MBR_KORR(uint32, mi_uint3korr, mi_int3store, 3);
+      break;
     case HA_KEYTYPE_LONG_INT:
       RT_PAGE_MBR_KORR(int32, mi_sint4korr, mi_int4store, 4);
+      break;
     case HA_KEYTYPE_ULONG_INT:
       RT_PAGE_MBR_KORR(uint32, mi_uint4korr, mi_int4store, 4);
+      break;
 #ifdef HAVE_LONG_LONG
     case HA_KEYTYPE_LONGLONG:
       RT_PAGE_MBR_KORR(longlong, mi_sint8korr, mi_int8store, 8);
+      break;
     case HA_KEYTYPE_ULONGLONG:
       RT_PAGE_MBR_KORR(ulonglong, mi_uint8korr, mi_int8store, 8);
+      break;
 #endif
     case HA_KEYTYPE_FLOAT:
       RT_PAGE_MBR_GET(float, mi_float4get, mi_float4store, 4);
+      break;
     case HA_KEYTYPE_DOUBLE:
       RT_PAGE_MBR_GET(double, mi_float8get, mi_float8store, 8);
+      break;
     case HA_KEYTYPE_END:
       return 0;
+    default:
+      return 1;
     }
   }
   return 0;
 }
+
+#endif /*HAVE_RTREE_KEYS*/
diff --git a/myisam/rt_mbr.h b/myisam/rt_mbr.h
index a68807370f9..2153faad2b4 100644
--- a/myisam/rt_mbr.h
+++ b/myisam/rt_mbr.h
@@ -18,6 +18,8 @@
 #ifndef _rt_mbr_h
 #define _rt_mbr_h
 
+#ifdef HAVE_RTREE_KEYS
+
 int rtree_key_cmp(HA_KEYSEG *keyseg, uchar *a, uchar *b, uint key_length,
                   uint nextflag);
 int rtree_combine_rect(HA_KEYSEG *keyseg,uchar *, uchar *, uchar*, 
@@ -28,6 +30,9 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar *a, uchar *b,
                               uint key_length);
 double rtree_area_increase(HA_KEYSEG *keyseg, uchar *a, uchar *b, 
                            uint key_length, double *ab_area);
+double rtree_perimeter_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b, 
+				uint key_length, double *ab_perim);
 int rtree_page_mbr(MI_INFO *info, HA_KEYSEG *keyseg, uchar *page_buf, 
                    uchar* c, uint key_length);
+#endif /*HAVE_RTREE_KEYS*/
 #endif /* _rt_mbr_h */
diff --git a/myisam/rt_split.c b/myisam/rt_split.c
index 62b8ea6a65b..005e86805bb 100644
--- a/myisam/rt_split.c
+++ b/myisam/rt_split.c
@@ -17,6 +17,8 @@
 
 #include "myisamdef.h"
 
+#ifdef HAVE_RTREE_KEYS
+
 #include "rt_index.h"
 #include "rt_key.h"
 #include "rt_mbr.h"
@@ -265,12 +267,12 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
 
   n_dim = keyinfo->keysegs / 2;
   
-  if (!my_multi_malloc(MYF(0),
-		       &coord_buf, n_dim * 2 * sizeof(double) * (max_keys + 1 + 4),
-		       &task, sizeof(SplitStruct) * (max_keys + 1),
-		       NullS))
+  if (!(coord_buf= my_alloca(n_dim * 2 * sizeof(double) * (max_keys + 1 + 4) +
+			     sizeof(SplitStruct) * (max_keys + 1))))
     return -1;
 
+  task= (SplitStruct *)(coord_buf + n_dim * 2 * (max_keys + 1 + 4));
+
   next_coord = coord_buf;
  
   stop = task + max_keys;
@@ -343,6 +345,8 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
   my_afree((byte*)new_page);
 
 split_err:
-  my_free((gptr) coord_buf, MYF(0));
+  my_afree((byte*) coord_buf);
   return err_code;
 }
+
+#endif /*HAVE_RTREE_KEYS*/
diff --git a/myisam/rt_test.c b/myisam/rt_test.c
index 41cc56d4d78..5e883e223b3 100644
--- a/myisam/rt_test.c
+++ b/myisam/rt_test.c
@@ -19,6 +19,9 @@
 
 
 #include "myisam.h"
+
+#ifdef HAVE_RTREE_KEYS
+
 #include "rt_index.h"
 
 #define MAX_REC_LENGTH 1024
@@ -31,6 +34,51 @@ static void create_record1(char *record,uint rownr);
 static void print_record(char * record,my_off_t offs,const char * tail);
 static  int run_test(const char *filename);
 
+static double rt_data[]=
+{
+  /*1*/  0,10,0,10,
+  /*2*/  5,15,0,10,
+  /*3*/  0,10,5,15,
+  /*4*/  10,20,10,20,
+  /*5*/  0,10,0,10,
+  /*6*/  5,15,0,10,
+  /*7*/  0,10,5,15,
+  /*8*/  10,20,10,20,
+  /*9*/  0,10,0,10,
+  /*10*/  5,15,0,10,
+  /*11*/  0,10,5,15,
+  /*12*/  10,20,10,20,
+  /*13*/  0,10,0,10,
+  /*14*/  5,15,0,10,
+  /*15*/  0,10,5,15,
+  /*16*/  10,20,10,20,
+  /*17*/  5,15,0,10,
+  /*18*/  0,10,5,15,
+  /*19*/  10,20,10,20,
+  /*20*/  0,10,0,10,
+
+  /*1*/  100,110,0,10,
+  /*2*/  105,115,0,10,
+  /*3*/  100,110,5,15,
+  /*4*/  110,120,10,20,
+  /*5*/  100,110,0,10,
+  /*6*/  105,115,0,10,
+  /*7*/  100,110,5,15,
+  /*8*/  110,120,10,20,
+  /*9*/  100,110,0,10,
+  /*10*/  105,115,0,10,
+  /*11*/  100,110,5,15,
+  /*12*/  110,120,10,20,
+  /*13*/  100,110,0,10,
+  /*14*/  105,115,0,10,
+  /*15*/  100,110,5,15,
+  /*16*/  110,120,10,20,
+  /*17*/  105,115,0,10,
+  /*18*/  100,110,5,15,
+  /*19*/  110,120,10,20,
+  /*20*/  100,110,0,10,
+  -1
+};
 
 int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
 {
@@ -55,7 +103,7 @@ static int run_test(const char *filename)
   int key_type=HA_KEYTYPE_DOUBLE;
   int key_length=8;
   int null_fields=0;
-  int nrecords=300;
+  int nrecords=sizeof(rt_data)/(sizeof(double)*4);/* 3000;*/
   int rec_length=0;
   int uniques=0;
   int i;
@@ -378,7 +426,7 @@ static void create_record1(char *record,uint rownr)
 }
 
 
-static void create_record(char *record,uint rownr)
+static void create_record0(char *record,uint rownr)
 {
    int i;
    char * pos;
@@ -398,3 +446,23 @@ static void create_record(char *record,uint rownr)
       pos+=sizeof(c);
    }
 }
+
+static void create_record(char *record,uint rownr)
+{
+   int i;
+   char *pos;
+   double *data= rt_data+rownr*4;
+   record[0]=0x01; /* DEL marker */
+   for ( pos=record+1, i=0; i<ndims*2; i++)
+   {
+      float8store(pos,data[i]);
+      pos+=8;
+   }
+}
+
+#else
+int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
+{
+  exit(0);
+}
+#endif /*HAVE_RTREE_KEYS*/
diff --git a/myisam/sort.c b/myisam/sort.c
index 1a9daa7df64..334f735599f 100644
--- a/myisam/sort.c
+++ b/myisam/sort.c
@@ -874,7 +874,8 @@ merge_buffers(MI_SORT_PARAM *info, uint keys, IO_CACHE *from_file,
     count+= buffpek->count;
     buffpek->base= strpos;
     buffpek->max_keys=maxcount;
-    strpos+= (uint) (error=(int) info->read_to_buffer(from_file,buffpek,sort_length));
+    strpos+= (uint) (error=(int) info->read_to_buffer(from_file,buffpek,
+                                                      sort_length));
     if (error == -1)
       goto err; /* purecov: inspected */
     queue_insert(&queue,(char*) buffpek);
@@ -891,7 +892,8 @@ merge_buffers(MI_SORT_PARAM *info, uint keys, IO_CACHE *from_file,
       buffpek=(BUFFPEK*) queue_top(&queue);
       if (to_file)
       {
-        if (info->write_key(info,to_file,(byte*) buffpek->key,(uint) sort_length,1))
+        if (info->write_key(info,to_file,(byte*) buffpek->key,
+                            (uint) sort_length,1))
         {
           error=1; goto err; /* purecov: inspected */
         }
diff --git a/myisam/sp_defs.h b/myisam/sp_defs.h
index 0acefe32f80..4cc2267a1bd 100644
--- a/myisam/sp_defs.h
+++ b/myisam/sp_defs.h
@@ -22,6 +22,8 @@
 #define SPTYPE HA_KEYTYPE_DOUBLE
 #define SPLEN  8
 
+#ifdef HAVE_SPATIAL
+
 enum wkbType
 {
   wkbPoint = 1,
@@ -42,4 +44,5 @@ enum wkbByteOrder
 uint sp_make_key(register MI_INFO *info, uint keynr, uchar *key,
                  const byte *record, my_off_t filepos);
 
+#endif /*HAVE_SPATIAL*/
 #endif /* _SP_DEFS_H */
diff --git a/myisam/sp_key.c b/myisam/sp_key.c
index f669d217026..0e424a9e193 100644
--- a/myisam/sp_key.c
+++ b/myisam/sp_key.c
@@ -15,6 +15,9 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #include "myisamdef.h"
+
+#ifdef HAVE_SPATIAL
+
 #include "sp_defs.h"
 
 static int sp_add_point_to_mbr(uchar *(*wkb), uchar *end, uint n_dims, 
@@ -284,3 +287,5 @@ static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
   }
   return res;
 }
+
+#endif /*HAVE_SPATIAL*/
diff --git a/myisam/sp_test.c b/myisam/sp_test.c
index 29c5f47471a..f0b48dbd5d8 100644
--- a/myisam/sp_test.c
+++ b/myisam/sp_test.c
@@ -18,6 +18,8 @@
 /* Written by Alex Barkov, who has a shared copyright to this code */
 
 #include "myisam.h"
+
+#ifdef HAVE_SPATIAL
 #include "sp_defs.h"
 
 #define MAX_REC_LENGTH 1024
@@ -553,3 +555,11 @@ static void rtree_PrintWKB(uchar *wkb, uint n_dims)
     }
   }
 }
+
+#else
+int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
+{
+  exit(0);
+}
+#endif /*HAVE_SPATIAL*/
+