X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=dict%2Finsert.c;h=db7fa69e7bb4653823873773ec2786b84db25d60;hb=bbc5017bf20ab7e410b4913acd70816812b5059f;hp=396640aa3c51732fb949b8c5691de4d1a259f1e3;hpb=1209da2618a90d6a811311becdbe2126ffdaa0de;p=idzebra-moved-to-github.git

diff --git a/dict/insert.c b/dict/insert.c
index 396640a..db7fa69 100644
--- a/dict/insert.c
+++ b/dict/insert.c
@@ -1,10 +1,26 @@
 /*
- * Copyright (C) 1994, Index Data I/S 
+ * Copyright (C) 1994-1998, Index Data I/S 
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: insert.c,v $
- * Revision 1.14  1995-12-07 11:48:56  adam
+ * 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.
+ *
+ * Revision 1.14  1995/12/07  11:48:56  adam
  * Insert operation obeys DICT_type = 1 (slack in page).
  * Function dict_open exists if page size or magic aren't right.
  *
@@ -118,6 +134,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 */
@@ -147,22 +164,25 @@ 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 */
-        assert (*info == best_char);
-        slen = dict_strlen(info);
+        memcpy (&dc, info, sizeof(dc));
+        assert (dc == best_char);
+        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);
         }
     }
@@ -212,7 +232,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;
@@ -292,20 +312,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);
@@ -332,9 +355,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,
@@ -356,10 +379,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);
@@ -374,7 +399,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));
@@ -460,12 +485,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);
 }