Added a few casts from zint to double/int where appropriate.

[idzebra-moved-to-github.git] / isamb / isamb.c

diff --git a/isamb/isamb.c b/isamb/isamb.c
index ddc936b..675c21e 100644 (file)
--- a/isamb/isamb.c
+++ b/isamb/isamb.c
@@ -1,6 +1,6 @@
-/* $Id: isamb.c,v 1.67 2005-01-15 18:43:05 adam Exp $
+/* $Id: isamb.c,v 1.73 2005-03-08 14:02:15 adam Exp $
    Copyright (C) 1995-2005
-   Index Data Aps
+   Index Data ApS
 
 This file is part of the Zebra server.
 
@@ -20,6 +20,7 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.
 */
 
+#include <stdlib.h>
 #include <string.h>
 #include <yaz/log.h>
 #include <yaz/xmalloc.h>
@@ -44,7 +45,7 @@ struct ISAMB_head {
     int block_offset;
 };
 
-/* if 1, interior nodes items are encoded; 0 if not encoded */
+/* if 1, upper nodes items are encoded; 0 if not encoded */
 #define INT_ENCODE 1
 
 /* maximum size of encoded buffer */
@@ -140,10 +141,10 @@ static void encode_ptr(char **dst, zint pos)
 
     while (pos > 127)
     {
-         *bp++ = 128 | (pos & 127);
+         *bp++ = (unsigned char) (128 | (pos & 127));
          pos = pos >> 7;
     }
-    *bp++ = pos;
+    *bp++ = (unsigned char) pos;
     *dst = (char *) bp;
 }
 #else
@@ -187,15 +188,15 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
 
     isamb->bfs = bfs;
     isamb->method = (ISAMC_M *) xmalloc(sizeof(*method));
-    memcpy (isamb->method, method, sizeof(*method));
+    memcpy(isamb->method, method, sizeof(*method));
     isamb->no_cat = CAT_NO;
     isamb->log_io = 0;
     isamb->log_freelist = 0;
     isamb->cache = cache;
     isamb->skipped_numbers = 0;
     isamb->returned_numbers = 0;
-    for (i = 0;i<ISAMB_MAX_LEVEL;i++)
-      isamb->skipped_nodes[i]= isamb->accessed_nodes[i]=0;
+    for (i = 0; i<ISAMB_MAX_LEVEL; i++)
+      isamb->skipped_nodes[i] = isamb->accessed_nodes[i] = 0;
 
     assert(cache == 0);
     isamb->file = xmalloc(sizeof(*isamb->file) * isamb->no_cat);
@@ -265,9 +266,9 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
            decode_ptr(&src, &isamb->file[i].head.first_block);
            decode_ptr(&src, &isamb->file[i].head.last_block);
            decode_ptr(&src, &zint_tmp);
-           isamb->file[i].head.block_size = zint_tmp;
+           isamb->file[i].head.block_size = (int) zint_tmp;
            decode_ptr(&src, &zint_tmp);
-           isamb->file[i].head.block_max = zint_tmp;
+           isamb->file[i].head.block_max = (int) zint_tmp;
            decode_ptr(&src, &isamb->file[i].head.free_list);
        }
         assert (isamb->file[i].head.block_size >= isamb->file[i].head.block_offset);
@@ -298,7 +299,7 @@ static void flush_blocks (ISAMB b, int cat)
     }
 }
 
-static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
+static int cache_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
 {
     int cat = (int) (pos&CAT_MASK);
     int off = (int) (((pos/CAT_MAX) & 
@@ -343,7 +344,7 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
         *ce_last = 0;  /* remove the last entry from list */
         if (ce_this->dirty)
         {
-            yaz_log(b->log_io, "bf_write: get_block");
+            yaz_log(b->log_io, "bf_write: cache_block");
             bf_write(b->file[cat].bf, ce_this->pos, 0, 0, ce_this->buf);
         }
         xfree(ce_this->buf);
@@ -354,7 +355,7 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
     b->file[cat].cache_entries = ce_this;
     ce_this->buf = xmalloc(ISAMB_CACHE_ENTRY_SIZE);
     ce_this->pos = norm;
-    yaz_log(b->log_io, "bf_read: get_block");
+    yaz_log(b->log_io, "bf_read: cache_block");
     if (!bf_read(b->file[cat].bf, norm, 0, 0, ce_this->buf))
         memset (ce_this->buf, 0, ISAMB_CACHE_ENTRY_SIZE);
     if (wr)
@@ -374,7 +375,7 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
 void isamb_close (ISAMB isamb)
 {
     int i;
-    for (i = 0;isamb->accessed_nodes[i];i++)
+    for (i = 0; isamb->accessed_nodes[i]; i++)
         yaz_log(YLOG_DEBUG, "isamb_close  level leaf-%d: "ZINT_FORMAT" read, "
                        ZINT_FORMAT" skipped",
              i, isamb->accessed_nodes[i], isamb->skipped_nodes[i]);
@@ -445,7 +446,7 @@ static struct ISAMB_block *open_block(ISAMB b, ISAMC_P pos)
     p->buf = xmalloc(b->file[cat].head.block_size);
     p->cbuf = 0;
 
-    if (!get_block (b, pos, p->buf, 0))
+    if (!cache_block (b, pos, p->buf, 0))
     {
         yaz_log(b->log_io, "bf_read: open_block");
         if (!bf_read(b->file[cat].bf, pos/CAT_MAX, 0, 0, p->buf))
@@ -491,7 +492,7 @@ struct ISAMB_block *new_block (ISAMB b, int leaf, int cat)
     {
         p->pos = b->file[cat].head.free_list;
         assert((p->pos & CAT_MASK) == cat);
-        if (!get_block (b, p->pos, p->buf, 0))
+        if (!cache_block (b, p->pos, p->buf, 0))
         {
             yaz_log(b->log_io, "bf_read: new_block");
             if (!bf_read(b->file[cat].bf, p->pos/CAT_MAX, 0, 0, p->buf))
@@ -581,7 +582,7 @@ void close_block(ISAMB b, struct ISAMB_block *p)
                  p->pos, p->cat, p->pos/CAT_MAX);
         memcpy (p->buf, &b->file[p->cat].head.free_list, sizeof(zint));
         b->file[p->cat].head.free_list = p->pos;
-        if (!get_block (b, p->pos, p->buf, 1))
+        if (!cache_block (b, p->pos, p->buf, 1))
         {
             yaz_log(b->log_io, "bf_write: close_block (deleted)");
             bf_write(b->file[p->cat].bf, p->pos/CAT_MAX, 0, 0, p->buf);
@@ -601,7 +602,7 @@ void close_block(ISAMB b, struct ISAMB_block *p)
         p->buf[2] = size >> 8;
        encode_ptr(&dst, p->no_items);
         check_block(b, p);
-        if (!get_block (b, p->pos, p->buf, 1))
+        if (!cache_block (b, p->pos, p->buf, 1))
         {
             yaz_log(b->log_io, "bf_write: close_block");
             bf_write(b->file[p->cat].bf, p->pos/CAT_MAX, 0, 0, p->buf);
@@ -703,7 +704,9 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
         /* there was a split - must insert pointer in this one */
         char dst_buf[DST_BUF_SIZE];
         char *dst = dst_buf;
-
+#if INT_ENCODE
+       const char *sub_item_ptr = sub_item;
+#endif
         assert (sub_size < 80 && sub_size > 1);
 
         memcpy (dst, startp, src - startp);
@@ -711,7 +714,6 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
         dst += src - startp;
 
 #if INT_ENCODE
-       const char *sub_item_ptr = sub_item;
        (*b->method->codec.reset)(c1);
         (*b->method->codec.encode)(c1, &dst, &sub_item_ptr);
 #else
@@ -741,6 +743,8 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
            /* must split _this_ block as well .. */
            struct ISAMB_block *sub_p3;
 #if INT_ENCODE
+           char file_item_buf[DST_ITEM_MAX];
+           char *file_item = file_item_buf;
 #else
            zint split_size_tmp;
 #endif
@@ -761,8 +765,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
             while (src <= half)
             {
 #if INT_ENCODE
-               char file_item_buf[DST_ITEM_MAX];
-               char *file_item = file_item_buf;
+               file_item = file_item_buf;
                (*b->method->codec.reset)(c1);
                (*b->method->codec.decode)(c1, &file_item, &src);
 #else
@@ -782,8 +785,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
             memcpy (p->bytes, dst_buf, p_new_size);
 
 #if INT_ENCODE
-           char file_item_buf[DST_ITEM_MAX];
-           char *file_item = file_item_buf;
+           file_item = file_item_buf;
            (*b->method->codec.reset)(c1);
            (*b->method->codec.decode)(c1, &file_item, &src);
            *split_size = file_item - file_item_buf;
@@ -1112,10 +1114,11 @@ int isamb_unlink (ISAMB b, ISAMC_P pos)
     {
        zint sub_p;
        const char *src = p1->bytes + p1->offset;
-
+#if INT_ENCODE
+       void *c1 = (*b->method->codec.start)();
+#endif
        decode_ptr(&src, &sub_p);
        isamb_unlink(b, sub_p);
-       void *c1 = (*b->method->codec.start)();
        
        while (src != p1->bytes + p1->size)
        {
@@ -1132,7 +1135,9 @@ int isamb_unlink (ISAMB b, ISAMC_P pos)
            decode_ptr(&src, &sub_p);
            isamb_unlink(b, sub_p);
        }
+#if INT_ENCODE
        (*b->method->codec.stop)(c1);
+#endif
     }
     close_block(b, p1);
     return 0;
@@ -1173,12 +1178,14 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream)
         {    /* increase level of tree by one */
             struct ISAMB_block *p2 = new_int (b, p->cat);
             char *dst = p2->bytes + p2->size;
+#if INT_ENCODE
            void *c1 = (*b->method->codec.start)();
-            
+           const char *sub_item_ptr = sub_item;
+#endif
+
             encode_ptr(&dst, p->pos);
            assert (sub_size < 80 && sub_size > 1);
 #if INT_ENCODE
-           const char *sub_item_ptr = sub_item;
            (*b->method->codec.reset)(c1);
            (*b->method->codec.encode)(c1, &dst, &sub_item_ptr);
 #else
@@ -1193,7 +1200,9 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream)
             pos = p2->pos;  /* return new super page */
             close_block(b, sp);
             close_block(b, p2);
+#if INT_ENCODE
            (*b->method->codec.stop)(c1);
+#endif
         }
         else
        {
@@ -1231,8 +1240,8 @@ ISAMB_PP isamb_pp_open_x(ISAMB isamb, ISAMB_P pos, int *level, int scope)
     pp->skipped_numbers = 0;
     pp->returned_numbers = 0;
     pp->scope = scope;
-    for (i = 0;i<ISAMB_MAX_LEVEL;i++)
-        pp->skipped_nodes[i] = pp->accessed_nodes[i]=0;
+    for (i = 0; i<ISAMB_MAX_LEVEL; i++)
+        pp->skipped_nodes[i] = pp->accessed_nodes[i] = 0;
     while (1)
     {
         struct ISAMB_block *p = open_block(isamb, pos);
@@ -1260,7 +1269,7 @@ ISAMB_PP isamb_pp_open (ISAMB isamb, ISAMB_P pos, int scope)
     return isamb_pp_open_x(isamb, pos, 0, scope);
 }
 
-void isamb_pp_close_x(ISAMB_PP pp, int *size, int *blocks)
+void isamb_pp_close_x(ISAMB_PP pp, zint *size, zint *blocks)
 {
     int i;
     if (!pp)
@@ -1268,14 +1277,14 @@ void isamb_pp_close_x(ISAMB_PP pp, int *size, int *blocks)
     yaz_log(YLOG_DEBUG, "isamb_pp_close lev=%d returned "ZINT_FORMAT" values, " 
                    "skipped "ZINT_FORMAT,
         pp->maxlevel, pp->skipped_numbers, pp->returned_numbers);
-    for (i = pp->maxlevel;i>=0;i--)
+    for (i = pp->maxlevel; i>=0; i--)
         if (pp->skipped_nodes[i] || pp->accessed_nodes[i])
             yaz_log(YLOG_DEBUG, "isamb_pp_close  level leaf-%d: "
                            ZINT_FORMAT" read, "ZINT_FORMAT" skipped", i,
                  pp->accessed_nodes[i], pp->skipped_nodes[i]);
     pp->isamb->skipped_numbers += pp->skipped_numbers;
     pp->isamb->returned_numbers += pp->returned_numbers;
-    for (i = pp->maxlevel;i>=0;i--)
+    for (i = pp->maxlevel; i>=0; i--)
     {
         pp->isamb->accessed_nodes[i] += pp->accessed_nodes[i];
         pp->isamb->skipped_nodes[i] += pp->skipped_nodes[i];
@@ -1504,7 +1513,6 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
   /* returns the node to (consider to) descend to in *pos) */
     struct ISAMB_block *p = pp->block[pp->level];
     const char *src;
-    ISAMB b = pp->isamb;
 #if ISAMB_DEBUG
     yaz_log(YLOG_DEBUG, "isamb_pp_climb_level starting "
                    "at level %d node %d ofs=%d sz=%d",
@@ -1521,7 +1529,7 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
     }
     assert(pp->level>0); 
     close_block(pp->isamb, pp->block[pp->level]);
-    pp->block[pp->level]=0;
+    pp->block[pp->level] = 0;
     (pp->level)--;
     p = pp->block[pp->level];
 #if ISAMB_DEBUG
@@ -1539,6 +1547,14 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
     }
     else
     {
+#if INT_ENCODE
+       char file_item_buf[DST_ITEM_MAX];
+       char *file_item = file_item_buf;
+        ISAMB b = pp->isamb;
+       void *c1 = (*b->method->codec.start)();
+#else
+       zint item_len;
+#endif
         /* skip the child we just came from */
 #if ISAMB_DEBUG
         yaz_log(YLOG_DEBUG, "isam_pp_climb_level: skipping lev=%d ofs=%d sz=%d", 
@@ -1547,13 +1563,9 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
         assert (p->offset < p->size);
         src = p->bytes + p->offset;
 #if INT_ENCODE
-       char file_item_buf[DST_ITEM_MAX];
-       char *file_item = file_item_buf;
-       void *c1 = (*b->method->codec.start)();
        (*b->method->codec.decode)(c1, &file_item, &src);
        (*b->method->codec.stop)(c1);
 #else
-       zint item_len;
        decode_item_len(&src, &item_len);
         src += item_len;
 #endif
@@ -1741,9 +1753,9 @@ int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf)
             if (isamb_pp_forward_on_leaf(pp, buf, untilbuf))
            {
 #if ISAMB_DEBUG
-            yaz_log(YLOG_DEBUG, "isamb_pp_forward (f) returning (C) "
-                   "at level %d node %d ofs=%d sz=%d",
-                    pp->level, p->pos, p->offset, p->size);
+               yaz_log(YLOG_DEBUG, "isamb_pp_forward (f) returning (c) "
+                       "at level %d node %d ofs=%d sz=%d",
+                       pp->level, p->pos, p->offset, p->size);
 #endif
                 return 1;
             }
@@ -1786,7 +1798,7 @@ void isamb_pp_pos(ISAMB_PP pp, double *current, double *total)
     assert(current);
     assert(p->leaf);
 
-    *total = pp->block[0]->no_items;
+    *total = (double) (pp->block[0]->no_items);
     *current = (double) pp->returned_numbers;
 #if ISAMB_DEBUG
     yaz_log(YLOG_LOG, "isamb_pp_pos returning: cur= %0.1f tot=%0.1f rn="