Work on dict_compact routine.

[idzebra-moved-to-github.git] / dict / insert.c

diff --git a/dict/insert.c b/dict/insert.c
index 5ec6d4c..af7775b 100644 (file)
--- a/dict/insert.c
+++ b/dict/insert.c
@@ -1,10 +1,24 @@
 /*
- * Copyright (C) 1994, Index Data I/S 
+ * Copyright (C) 1994-1999, Index Data
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: insert.c,v $
- * Revision 1.15  1996-02-01 20:39:59  adam
+ * Revision 1.19  1999-02-02 14:50:22  adam
+ * Updated WIN32 code specific sections. Changed header.
+ *
+ * Revision 1.18  1998/03/05 08:17:24  adam
+ * Added a few comments - no code changed.
+ *
+ * Revision 1.17  1996/05/14 15:49:09  adam
+ * Bug fix: In function split_page. In rare cases variable best_indxp was
+ * referenced.
+ *
+ * Revision 1.16  1996/02/02  13:43:50  adam
+ * The public functions simply use char instead of Dict_char to represent
+ * search strings. Dict_char is used internally only.
+ *
+ * Revision 1.15  1996/02/01  20:39:59  adam
  * Bug fix: insert didn't work on 8-bit characters due to unsigned char
  * compares in dict_strcmp (strcmp) and signed Dict_char. Dict_char is
  * unsigned now.
@@ -123,6 +137,7 @@ static int split_page (Dict dict, Dict_ptr ptr, void *p)
             {   /* first entry met */
                 best_char = prev_char = dc;
                 best_no = 1;
+                best_indxp = indxp;
             }
             else if (prev_char == dc)
             {   /* same char prefix. update */
@@ -153,24 +168,24 @@ static int split_page (Dict dict, Dict_ptr ptr, void *p)
         char *info, *info1;
         int slen;
         Dict_char dc;
-        
 
         info = (char*) p + ((short*) p)[j];
         /* entry start */
         memcpy (&dc, info, sizeof(dc));
         assert (dc == best_char);
-        slen = dict_strlen(info);
+        slen = 1+dict_strlen((Dict_char*) info);
 
-        assert (slen > 0);
-        if (slen == 1)
+        assert (slen > 1);
+        if (slen == 2)
         {
             assert (!info_here);
-            info_here = info+(slen+1)*sizeof(Dict_char);
+            info_here = info+slen*sizeof(Dict_char);
         }
         else
         {
-            info1 = info+(1+slen)*sizeof(Dict_char);  /* info start */
-            dict_ins (dict, info+sizeof(Dict_char), subptr, *info1, info1+1);
+            info1 = info+slen*sizeof(Dict_char);  /* info start */
+            dict_ins (dict, (Dict_char*) (info+sizeof(Dict_char)),
+                      subptr, *info1, info1+1);
             dict_bf_readp (dict->dbf, ptr, &p);
         }
     }
@@ -220,7 +235,7 @@ static void clean_page (Dict dict, Dict_ptr ptr, void *p, Dict_char *out,
                 continue;
            }
             *--indxp2 = info2 - np;
-            slen = (dict_strlen(info1)+1)*sizeof(Dict_char);
+            slen = (dict_strlen((Dict_char*) info1)+1)*sizeof(Dict_char);
             memcpy (info2, info1, slen);
            info1 += slen;
             info2 += slen;
@@ -300,20 +315,23 @@ static int dict_ins (Dict dict, const Dict_char *str,
             cmp = dict_strcmp((Dict_char*) info, str);
             if (!cmp)
             {
-                info += (dict_strlen(info)+1)*sizeof(Dict_char);
+                info += (dict_strlen((Dict_char*) info)+1)*sizeof(Dict_char);
                 /* consider change of userinfo length... */
                 if (*info == userlen)
                 {
+                   /* change of userinfo ? */
                     if (memcmp (info+1, userinfo, userlen))
                     {
                         dict_bf_touch (dict->dbf, ptr);
                         memcpy (info+1, userinfo, userlen);
                         return 1;
                     }
+                   /* same userinfo */
                     return 2;
                 }
                 else if (*info > userlen)
                 {
+                   /* room for new userinfo */
                     DICT_type(p) = 1;
                     *info = userlen;
                     dict_bf_touch (dict->dbf, ptr);
@@ -340,9 +358,9 @@ static int dict_ins (Dict dict, const Dict_char *str,
                 memcpy (&subptr, info, sizeof(Dict_ptr));
                 if (*++str == DICT_EOS)
                 {
-                    int xlen;
-                    
-                    xlen = info[sizeof(Dict_ptr)+sizeof(Dict_char)];
+                   /* finish of string. Store userinfo here... */
+
+                    int xlen = info[sizeof(Dict_ptr)+sizeof(Dict_char)];
                     if (xlen == userlen)
                     {
                         if (memcmp (info+sizeof(Dict_ptr)+sizeof(Dict_char)+1,
@@ -364,10 +382,12 @@ static int dict_ins (Dict dict, const Dict_char *str,
                         dict_bf_touch (dict->dbf, ptr);
                         return 1;
                     }
+                   /* xlen < userlen, expanding needed ... */
                     if (DICT_size(p)+sizeof(Dict_char)+sizeof(Dict_ptr)+
                         userlen >=
                         DICT_pagesize(dict) - (1+DICT_nodir(p))*sizeof(short))
                     {
+                       /* not enough room - split needed ... */
                         if (DICT_type(p) == 1)
                         {
                             clean_page (dict, ptr, p, NULL, 0, NULL);
@@ -382,7 +402,7 @@ static int dict_ins (Dict dict, const Dict_char *str,
                         return dict_ins (dict, str-1, ptr, userlen, userinfo);
                     }
                     else
-                    {
+                    {   /* enough room - no split needed ... */
                         info = (char*)p + DICT_size(p);
                         memcpy (info, &subptr, sizeof(subptr));
                         memcpy (info+sizeof(Dict_ptr), &dc, sizeof(Dict_char));
@@ -468,12 +488,12 @@ static int dict_ins (Dict dict, const Dict_char *str,
     return 1;
 }
 
-int dict_insert (Dict dict, const Dict_char *str, int userlen, void *userinfo)
+int dict_insert (Dict dict, const char *str, int userlen, void *userinfo)
 {
     assert (dict->head.last > 0);
     if (dict->head.last == 1)
-        return dict_ins (dict, str, 0, userlen, userinfo);
+        return dict_ins (dict, (const Dict_char *) str, 0, userlen, userinfo);
     else
-        return dict_ins (dict, str, 1, userlen, userinfo);
+        return dict_ins (dict, (const Dict_char *) str, 1, userlen, userinfo);
 }