C++ compilation.

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

diff --git a/dict/insert.c b/dict/insert.c
index af7775b..1057d67 100644 (file)
--- a/dict/insert.c
+++ b/dict/insert.c
@@ -4,7 +4,13 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: insert.c,v $
- * Revision 1.19  1999-02-02 14:50:22  adam
+ * Revision 1.21  1999-05-26 07:49:12  adam
+ * C++ compilation.
+ *
+ * Revision 1.20  1999/05/15 14:36:37  adam
+ * Updated dictionary. Implemented "compression" of dictionary.
+ *
+ * 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
@@ -88,26 +94,24 @@ static void clean_page (Dict dict, Dict_ptr ptr, void *p, Dict_char *out,
 static Dict_ptr new_page (Dict dict, Dict_ptr back_ptr, void **pp)
 {
     void *p;
-    Dict_ptr ptr = dict->head.free_list;
-    if (dict->head.free_list == dict->head.last)
+    Dict_ptr ptr = dict->head.last;
+    if (!dict->head.freelist)
     {
-        dict->head.free_list++;
-        dict->head.last = dict->head.free_list;
-        dict_bf_newp (dict->dbf, ptr, &p);
+        dict_bf_newp (dict->dbf, dict->head.last, &p, dict->head.page_size);
+       (dict->head.last)++;
     }
     else
     {
-        dict_bf_readp (dict->dbf, dict->head.free_list, &p);
-        dict->head.free_list = DICT_nextptr(p);
-        if (dict->head.free_list == 0)
-            dict->head.free_list = dict->head.last;
+       ptr = dict->head.freelist;
+        dict_bf_readp (dict->dbf, ptr, &p);
+        dict->head.freelist = DICT_backptr(p);
     }
     assert (p);
     DICT_type(p) = 0;
     DICT_backptr(p) = back_ptr;
-    DICT_nextptr(p) = 0;
     DICT_nodir(p) = 0;
     DICT_size(p) = DICT_infoffset;
+    DICT_bsize(p) = dict->head.page_size;
     if (pp)
         *pp = p;
     return ptr;
@@ -125,7 +129,7 @@ static int split_page (Dict dict, Dict_ptr ptr, void *p)
     int best_no = -1, no_current = 1;
 
     /* determine splitting char... */
-    indxp = (short*) ((char*) p+DICT_pagesize(dict)-sizeof(short));
+    indxp = (short*) ((char*) p+DICT_bsize(p)-sizeof(short));
     for (i = DICT_nodir (p); --i >= 0; --indxp)
     {
         if (*indxp > 0) /* tail string here! */
@@ -197,13 +201,14 @@ static int split_page (Dict dict, Dict_ptr ptr, void *p)
 static void clean_page (Dict dict, Dict_ptr ptr, void *p, Dict_char *out,
                         Dict_ptr subptr, char *userinfo)             
 {
-    char *np = xmalloc (dict->head.page_size);
+    char *np = (char *) xmalloc (dict->head.page_size);
     int i, slen, no = 0;
     short *indxp1, *indxp2;
     char *info1, *info2;
 
-    indxp1 = (short*) ((char*) p+DICT_pagesize(dict)-sizeof(short));
-    indxp2 = (short*) ((char*) np+DICT_pagesize(dict));
+    DICT_bsize(np) = dict->head.page_size;
+    indxp1 = (short*) ((char*) p+DICT_bsize(p)-sizeof(short));
+    indxp2 = (short*) ((char*) np+DICT_bsize(np));
     info2 = (char*) np + DICT_infoffset;
     for (i = DICT_nodir (p); --i >= 0; --indxp1)
     {
@@ -265,7 +270,7 @@ static void clean_page (Dict dict, Dict_ptr ptr, void *p, Dict_char *out,
             info2 - ((char*)np+DICT_infoffset));
     memcpy ((char*)p + ((char*)indxp2 - (char*)np),
             indxp2,
-            ((char*) np+DICT_pagesize(dict)) - (char*)indxp2);
+            ((char*) np+DICT_bsize(p)) - (char*)indxp2);
 #else
     memcpy ((char*)p+DICT_infoffset, (char*)np+DICT_infoffset,
             DICT_pagesize(dict)-DICT_infoffset);
@@ -284,25 +289,21 @@ static void clean_page (Dict dict, Dict_ptr ptr, void *p, Dict_char *out,
 /* return 2 if same as before */
 
 static int dict_ins (Dict dict, const Dict_char *str,
-                     Dict_ptr back_ptr, int userlen, void *userinfo)
+                     Dict_ptr ptr, int userlen, void *userinfo)
 {
     int hi, lo, mid, slen, cmp = 1;
-    Dict_ptr ptr = back_ptr;
     short *indxp;
     char *info;
     void *p;
 
-    if (ptr == 0)
-        ptr = new_page (dict, back_ptr, &p);
-    else
-        dict_bf_readp (dict->dbf, ptr, &p);
+    dict_bf_readp (dict->dbf, ptr, &p);
         
     assert (p);
     assert (ptr);
 
     mid = lo = 0;
     hi = DICT_nodir(p)-1;
-    indxp = (short*) ((char*) p+DICT_pagesize(dict)-sizeof(short));
+    indxp = (short*) ((char*) p+DICT_bsize(p)-sizeof(short));
     while (lo <= hi)
     {
         mid = (lo+hi)/2;
@@ -385,7 +386,7 @@ static int dict_ins (Dict dict, const Dict_char *str,
                    /* xlen < userlen, expanding needed ... */
                     if (DICT_size(p)+sizeof(Dict_char)+sizeof(Dict_ptr)+
                         userlen >=
-                        DICT_pagesize(dict) - (1+DICT_nodir(p))*sizeof(short))
+                        DICT_bsize(p) - (1+DICT_nodir(p))*sizeof(short))
                     {
                        /* not enough room - split needed ... */
                         if (DICT_type(p) == 1)
@@ -441,7 +442,7 @@ static int dict_ins (Dict dict, const Dict_char *str,
         --indxp;
     slen = (dict_strlen(str)+1)*sizeof(Dict_char);
     if (DICT_size(p)+slen+userlen >=
-        DICT_pagesize(dict) - (1+DICT_nodir(p))*sizeof(short)) /* overflow? */
+        (int)(DICT_bsize(p) - (1+DICT_nodir(p))*sizeof(short)))/* overflow? */
     {
         if (DICT_type(p))
         {
@@ -455,7 +456,7 @@ static int dict_ins (Dict dict, const Dict_char *str,
     {
         short *indxp1;
         (DICT_nodir(p))++;
-        indxp1 = (short*)((char*) p + DICT_pagesize(dict)
+        indxp1 = (short*)((char*) p + DICT_bsize(p)
                           - DICT_nodir(p)*sizeof(short));
         for (; indxp1 != indxp; indxp1++)
             indxp1[0] = indxp1[1];
@@ -490,10 +491,15 @@ static int dict_ins (Dict dict, const Dict_char *str,
 
 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, (const Dict_char *) str, 0, userlen, userinfo);
-    else
-        return dict_ins (dict, (const Dict_char *) str, 1, userlen, userinfo);
+    if (!dict->head.root)
+    {
+       void *p;
+       if (dict->rw)
+           dict->head.root = new_page (dict, 0, &p);
+       if (!dict->head.root)
+           return 0;
+    }
+    return dict_ins (dict, (const Dict_char *) str, dict->head.root,
+                    userlen, userinfo);
 }