X-Git-Url: http://lists.indexdata.dk/cgi-bin?a=blobdiff_plain;f=isamb%2Fisamb.c;h=8f62074062176b3df0138e27704550d8d87f4750;hb=4f992a15af3e29dfc561c4cfa4841ec0f858e7c8;hp=57ca28a1bdf81f924df046f703ce5a2c7eaf2576;hpb=e184d932ecfafa617833b4d45e123faa87969af1;p=idzebra-moved-to-github.git

diff --git a/isamb/isamb.c b/isamb/isamb.c
index 57ca28a..8f62074 100644
--- a/isamb/isamb.c
+++ b/isamb/isamb.c
@@ -1,5 +1,5 @@
-/* $Id: isamb.c,v 1.56 2004-08-23 13:06:46 adam Exp $
-   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
+/* $Id: isamb.c,v 1.66 2005-01-13 11:55:02 adam Exp $
+   Copyright (C) 1995-2005
    Index Data Aps
 
 This file is part of the Zebra server.
@@ -21,9 +21,9 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 */
 
 #include <string.h>
-#include <yaz/xmalloc.h>
 #include <yaz/log.h>
-#include <isamb.h>
+#include <yaz/xmalloc.h>
+#include <idzebra/isamb.h>
 #include <assert.h>
 
 #ifndef ISAMB_DEBUG
@@ -58,7 +58,7 @@ struct ISAMB_head {
 /* CAT_NO: <= CAT_MAX */
 #define CAT_NO 4
 
-/* ISAMB_PTR_CODEC=1 var, =0 fixed */
+/* ISAMB_PTR_CODEC = 1 var, =0 fixed */
 #define ISAMB_PTR_CODEC 1
 
 struct ISAMB_cache_entry {
@@ -82,12 +82,12 @@ struct ISAMB_s {
 
     struct ISAMB_file *file;
     int no_cat;
-    int cache; /* 0=no cache, 1=use cache, -1=dummy isam (for testing only) */
+    int cache; /* 0 = no cache, 1 = use cache, -1 = dummy isam (for testing only) */
     int log_io;        /* log level for bf_read/bf_write calls */
     int log_freelist;  /* log level for freelist handling */
     zint skipped_numbers; /* on a leaf node */
     zint returned_numbers; 
-    zint skipped_nodes[ISAMB_MAX_LEVEL]; /* [0]=skipped leaves, 1=higher etc */
+    zint skipped_nodes[ISAMB_MAX_LEVEL]; /* [0]=skipped leaves, 1 = higher etc */
     zint accessed_nodes[ISAMB_MAX_LEVEL]; /* nodes we did not skip */
 };
 
@@ -116,9 +116,10 @@ struct ISAMB_PP_s {
     zint no_blocks;
     zint skipped_numbers; /* on a leaf node */
     zint returned_numbers; 
-    zint skipped_nodes[ISAMB_MAX_LEVEL]; /* [0]=skipped leaves, 1=higher etc */
+    zint skipped_nodes[ISAMB_MAX_LEVEL]; /* [0]=skipped leaves, 1 = higher etc */
     zint accessed_nodes[ISAMB_MAX_LEVEL]; /* nodes we did not skip */
     struct ISAMB_block **block;
+    int scope;  /* on what level we forward */
 };
 
 
@@ -180,9 +181,9 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
     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_numbers = 0;
+    isamb->returned_numbers = 0;
+    for (i = 0;i<ISAMB_MAX_LEVEL;i++)
       isamb->skipped_nodes[i]= isamb->accessed_nodes[i]=0;
 
     assert (cache == 0);
@@ -204,10 +205,14 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
 	isamb->file[i].head.first_block = ISAMB_CACHE_ENTRY_SIZE/b_size+1;
 	isamb->file[i].head.last_block = isamb->file[i].head.first_block;
 	isamb->file[i].head.block_size = b_size;
+#if ISAMB_PTR_CODEC
 	if (i == isamb->no_cat-1 || b_size > 128)
 	    isamb->file[i].head.block_offset = 8;
 	else
 	    isamb->file[i].head.block_offset = 4;
+#else
+	isamb->file[i].head.block_offset = 11;
+#endif
 	isamb->file[i].head.block_max =
 	    b_size - isamb->file[i].head.block_offset;
 	isamb->file[i].head.free_list = 0;
@@ -220,17 +225,17 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
 	    const char *src = 0;
 	    if (memcmp(hbuf, "isamb", 5))
 	    {
-		logf(LOG_WARN, "bad isamb header for file %s", fname);
+		yaz_log(YLOG_WARN, "bad isamb header for file %s", fname);
 		return 0;
 	    }
 	    if (sscanf(hbuf+5, "%d %d %d", &major, &minor, &len) != 3)
 	    {
-		logf(LOG_WARN, "bad isamb header for file %s", fname);
+		yaz_log(YLOG_WARN, "bad isamb header for file %s", fname);
 		return 0;
 	    }
 	    if (major != ISAMB_MAJOR_VERSION)
 	    {
-		logf(LOG_WARN, "bad major version for file %s %d, must be %d",
+		yaz_log(YLOG_WARN, "bad major version for file %s %d, must be %d",
 		     fname, major, ISAMB_MAJOR_VERSION);
 		return 0;
 	    }
@@ -239,7 +244,7 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
 		pos++;
 		if (!bf_read (isamb->file[i].bf, pos, 0, 0, hbuf + pos*b_size))
 		{
-		    logf(LOG_WARN, "truncated isamb header for " 
+		    yaz_log(YLOG_WARN, "truncated isamb header for " 
 			 "file=%s len=%d pos=%d",
 			 fname, len, pos);
 		    return 0;
@@ -260,7 +265,7 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M *method,
         b_size = b_size * 4;
     }
 #if ISAMB_DEBUG
-    logf(LOG_WARN, "isamb debug enabled. Things will be slower than usual");
+    yaz_log(YLOG_WARN, "isamb debug enabled. Things will be slower than usual");
 #endif
     return isamb;
 }
@@ -358,11 +363,11 @@ 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++)
-        logf(LOG_DEBUG,"isamb_close  level leaf-%d: "ZINT_FORMAT" read, "
+    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]);
-    logf(LOG_DEBUG,"isamb_close returned "ZINT_FORMAT" values, "
+    yaz_log(YLOG_DEBUG, "isamb_close returned "ZINT_FORMAT" values, "
 		   "skipped "ZINT_FORMAT,
          isamb->skipped_numbers, isamb->returned_numbers);
     for (i = 0; i<isamb->no_cat; i++)
@@ -383,7 +388,7 @@ void isamb_close (ISAMB isamb)
 	    encode_ptr(&dst, isamb->file[i].head.block_size);
 	    encode_ptr(&dst, isamb->file[i].head.block_max);
 	    encode_ptr(&dst, isamb->file[i].head.free_list);
-	    memset(dst, '\0', 16); /* ensure no random bytes are written */
+	    memset(dst, '\0', b_size); /* ensure no random bytes are written */
 
 	    len = dst - hbuf;
 
@@ -434,7 +439,7 @@ static struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
         yaz_log (b->log_io, "bf_read: open_block");
         if (!bf_read (b->file[cat].bf, pos/CAT_MAX, 0, 0, p->buf))
         {
-            yaz_log (LOG_FATAL, "isamb: read fail for pos=%ld block=%ld",
+            yaz_log (YLOG_FATAL, "isamb: read fail for pos=%ld block=%ld",
                      (long) pos, (long) pos/CAT_MAX);
             abort();
         }
@@ -444,7 +449,7 @@ static struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
     p->size = (p->buf[1] + 256 * p->buf[2]) - offset;
     if (p->size < 0)
     {
-        yaz_log (LOG_FATAL, "Bad block size %d in pos=" ZINT_FORMAT "\n",
+        yaz_log (YLOG_FATAL, "Bad block size %d in pos=" ZINT_FORMAT "\n",
 		 p->size, pos);
     }
     assert (p->size >= 0);
@@ -480,14 +485,14 @@ struct ISAMB_block *new_block (ISAMB b, int leaf, int cat)
             yaz_log (b->log_io, "bf_read: new_block");
             if (!bf_read (b->file[cat].bf, p->pos/CAT_MAX, 0, 0, p->buf))
             {
-                yaz_log (LOG_FATAL, "isamb: read fail for pos=%ld block=%ld",
+                yaz_log (YLOG_FATAL, "isamb: read fail for pos=%ld block=%ld",
                          (long) p->pos/CAT_MAX, (long) p->pos/CAT_MAX);
                 abort ();
             }
         }
         yaz_log (b->log_freelist, "got block " ZINT_FORMAT " from freelist %d:" ZINT_FORMAT, p->pos,
                  cat, p->pos/CAT_MAX);
-        memcpy (&b->file[cat].head.free_list, p->buf, sizeof(int));
+        memcpy (&b->file[cat].head.free_list, p->buf, sizeof(zint));
     }
     p->cat = cat;
     b->file[cat].head_dirty = 1;
@@ -554,7 +559,7 @@ void close_block (ISAMB b, struct ISAMB_block *p)
     {
         yaz_log (b->log_freelist, "release block " ZINT_FORMAT " from freelist %d:" ZINT_FORMAT,
                  p->pos, p->cat, p->pos/CAT_MAX);
-        memcpy (p->buf, &b->file[p->cat].head.free_list, sizeof(int));
+        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))
         {
@@ -795,7 +800,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item,
 		/* if this is not an insertion, it's really bad .. */
                 if (!*lookahead_mode)
                 {
-                    yaz_log (LOG_WARN, "isamb: Inconsistent register (1)");
+                    yaz_log (YLOG_WARN, "isamb: Inconsistent register (1)");
                     assert (*lookahead_mode);
                 }
             }
@@ -911,7 +916,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item,
         if (!*lookahead_mode)
         {
 	    /* this is append. So a delete is bad */
-            yaz_log (LOG_WARN, "isamb: Inconsistent register (2)");
+            yaz_log (YLOG_WARN, "isamb: Inconsistent register (2)");
             abort();
         }
         else if (!half1 && dst > tail_cut)
@@ -1093,7 +1098,7 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream)
             char *dst = p2->bytes + p2->size;
             
             encode_ptr (&dst, p->pos);
-            assert (sub_size < 40);
+	    assert (sub_size < 80 && sub_size > 1);
             encode_ptr (&dst, sub_size);
             memcpy (dst, sub_item, sub_size);
             dst += sub_size;
@@ -1123,22 +1128,25 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream)
     return pos;
 }
 
-ISAMB_PP isamb_pp_open_x (ISAMB isamb, ISAMB_P pos, int *level)
+ISAMB_PP isamb_pp_open_x (ISAMB isamb, ISAMB_P pos, int *level, int scope)
 {
     ISAMB_PP pp = xmalloc (sizeof(*pp));
     int i;
 
+    assert(pos);
+
     pp->isamb = isamb;
     pp->block = xmalloc (ISAMB_MAX_LEVEL * sizeof(*pp->block));
 
     pp->pos = pos;
     pp->level = 0;
-    pp->maxlevel=0;
+    pp->maxlevel = 0;
     pp->total_size = 0;
     pp->no_blocks = 0;
-    pp->skipped_numbers=0;
-    pp->returned_numbers=0;
-    for (i=0;i<ISAMB_MAX_LEVEL;i++)
+    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;
     while (1)
     {
@@ -1150,23 +1158,21 @@ ISAMB_PP isamb_pp_open_x (ISAMB isamb, ISAMB_P pos, int *level)
         pp->no_blocks++;
         if (p->leaf)
             break;
-
-                                        
         decode_ptr (&src, &pos);
         p->offset = src - p->bytes;
         pp->level++;
         pp->accessed_nodes[pp->level]++; 
     }
     pp->block[pp->level+1] = 0;
-    pp->maxlevel=pp->level;
+    pp->maxlevel = pp->level;
     if (level)
         *level = pp->level;
     return pp;
 }
 
-ISAMB_PP isamb_pp_open (ISAMB isamb, ISAMB_P pos)
+ISAMB_PP isamb_pp_open (ISAMB isamb, ISAMB_P pos, int scope)
 {
-    return isamb_pp_open_x (isamb, pos, 0);
+    return isamb_pp_open_x (isamb, pos, 0, scope);
 }
 
 void isamb_pp_close_x (ISAMB_PP pp, int *size, int *blocks)
@@ -1174,17 +1180,17 @@ void isamb_pp_close_x (ISAMB_PP pp, int *size, int *blocks)
     int i;
     if (!pp)
         return;
-    logf(LOG_DEBUG,"isamb_pp_close lev=%d returned "ZINT_FORMAT" values," 
+    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--)
-        if ( pp->skipped_nodes[i] || pp->accessed_nodes[i])
-            logf(LOG_DEBUG,"isamb_pp_close  level leaf-%d: "
+    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];
@@ -1233,7 +1239,7 @@ static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str),
 		const char *src = p->bytes + p->offset;
 		char *dst = buf;
 		(*b->method->codec.decode)(p->decodeClientData, &dst, &src);
-		(*b->method->log_item)(LOG_DEBUG, buf, prefix_str);
+		(*b->method->log_item)(YLOG_DEBUG, buf, prefix_str);
 		p->offset = src - (char*) p->bytes;
 	    }
 	    assert(p->offset == p->size);
@@ -1252,7 +1258,7 @@ static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str),
 	    while (p->offset < p->size)
 	    {
 		decode_ptr (&src, &item_len);
-		(*b->method->log_item)(LOG_DEBUG, src, prefix_str);
+		(*b->method->log_item)(YLOG_DEBUG, src, prefix_str);
 		src += item_len;
 		decode_ptr (&src, &sub);
 		
@@ -1261,7 +1267,7 @@ static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str),
 		isamb_dump_r(b, sub, pr, level+1);
 	    }		
 	}
-	close_block(b,p);
+	close_block(b, p);
     }
 }
 
@@ -1270,80 +1276,11 @@ void isamb_dump (ISAMB b, ISAMB_P pos, void (*pr)(const char *str))
     isamb_dump_r(b, pos, pr, 0);
 }
 
-#if 0
-/* Old isamb_pp_read that Adam wrote, kept as a reference in case we need to
-   debug the more complex pp_read that also forwards. May be deleted near end
-   of 2004, if it has not shown to be useful */
-
-
-int isamb_pp_read (ISAMB_PP pp, void *buf)
-{
-    char *dst = buf;
-    char *src;
-    struct ISAMB_block *p = pp->block[pp->level];
-    if (!p)
-        return 0;
-
-    while (p->offset == p->size)
-    {
-        int pos, item_len;
-        while (p->offset == p->size)
-        {
-            if (pp->level == 0)
-                return 0;
-            close_block (pp->isamb, pp->block[pp->level]);
-            pp->block[pp->level] = 0;
-            (pp->level)--;
-            p = pp->block[pp->level];
-            assert (!p->leaf);  
-        }
-        src = p->bytes + p->offset;
-        
-        decode_ptr (&src, &item_len);
-        src += item_len;
-        decode_ptr (&src, &pos);
-        
-        p->offset = src - (char*) p->bytes;
-
-        ++(pp->level);
-        
-        while (1)
-        {
-            pp->block[pp->level] = p = open_block (pp->isamb, pos);
-
-            pp->total_size += p->size;
-            pp->no_blocks++;
-            
-            if (p->leaf) 
-            {
-                break;
-            }
-            src = p->bytes + p->offset;
-            decode_ptr (&src, &pos);
-            p->offset = src - (char*) p->bytes;
-            pp->level++;
-        }
-    }
-    assert (p->offset < p->size);
-    assert (p->leaf);
-    src = p->bytes + p->offset;
-    (*pp->isamb->method->codec.code_item)(ISAMC_DECODE, p->decodeClientData,
-                                    &dst, &src);
-    p->offset = src - (char*) p->bytes;
-    /* key_logdump_txt(LOG_DEBUG,buf, "isamb_pp_read returning 1"); */
-    return 1;
-}
-
-#else
 int isamb_pp_read (ISAMB_PP pp, void *buf)
 {
     return isamb_pp_forward(pp, buf, 0);
 }
-#endif
-
-#define NEW_FORWARD 1
 
-#if NEW_FORWARD == 1
 
 static int isamb_pp_on_right_node(ISAMB_PP pp, int level, const void *untilbuf)
 { /* looks one node higher to see if we should be on this node at all */
@@ -1354,44 +1291,46 @@ static int isamb_pp_on_right_node(ISAMB_PP pp, int level, const void *untilbuf)
     const char *src;
     zint item_len;
     assert(level>=0);
-    if ( level == 0) {
+    if (level == 0)
+    {
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_on_right returning true for root");
+            yaz_log(YLOG_DEBUG, "isamb_pp_on_right returning true for root");
 #endif
         return 1; /* we can never skip the root node */
     }
     level--;
-    p=pp->block[level];
+    p = pp->block[level];
     assert(p->offset <= p->size);
-    if (p->offset < p->size )
+    if (p->offset < p->size)
     {
         assert(p->offset>0); 
-        src=p->bytes + p->offset;
+        src = p->bytes + p->offset;
         decode_ptr(&src, &item_len);
 #if ISAMB_DEBUG
-        (*pp->isamb->method->codec.log_item)(LOG_DEBUG,untilbuf,"on_leaf: until");
-        (*pp->isamb->method->codec.log_item)(LOG_DEBUG,src,"on_leaf: value");
+        (*pp->isamb->method->codec.log_item)(YLOG_DEBUG, untilbuf, "on_leaf: until");
+        (*pp->isamb->method->codec.log_item)(YLOG_DEBUG, src, "on_leaf: value");
 #endif
-        cmp=(*pp->isamb->method->compare_item)(untilbuf,src);
-        if (cmp<2) {
+        cmp=(*pp->isamb->method->compare_item)(untilbuf, src);
+        if (cmp<pp->scope)
+	{  /* cmp<2 */
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_on_right returning true "
-                            "cmp=%d lev=%d ofs=%d",cmp,level,p->offset);
+            yaz_log(YLOG_DEBUG, "isamb_pp_on_right returning true "
+                            "cmp=%d lev=%d ofs=%d", cmp, level, p->offset);
 #endif
             return 1; 
         }
         else {
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_on_right returning false "
-                            "cmp=%d lev=%d ofs=%d",cmp,level,p->offset);
+            yaz_log(YLOG_DEBUG, "isamb_pp_on_right returning false "
+                            "cmp=%d lev=%d ofs=%d", cmp, level, p->offset);
 #endif
             return 0; 
         }
     }
     else {
 #if ISAMB_DEBUG
-        logf(LOG_DEBUG,"isamb_pp_on_right at tail, looking higher "
-                        "lev=%d",level);
+        yaz_log(YLOG_DEBUG, "isamb_pp_on_right at tail, looking higher "
+                        "lev=%d", level);
 #endif
         return isamb_pp_on_right_node(pp, level, untilbuf);
     }
@@ -1404,21 +1343,20 @@ static int isamb_pp_read_on_leaf(ISAMB_PP pp, void *buf)
     const char *src;
     assert(pp);
     assert(buf);
-    if (p->offset == p->size) {
+    if (p->offset == p->size)
+    {
 #if ISAMB_DEBUG
-        logf(LOG_DEBUG,"isamb_pp_read_on_leaf returning 0 on node %d",p->pos);
+        yaz_log(YLOG_DEBUG, "isamb_pp_read_on_leaf returning 0 on node %d", p->pos);
 #endif
         return 0; /* at end of leaf */
     }
-    src=p->bytes + p->offset;
-    dst=buf;
-    (*pp->isamb->method->codec.decode)(p->decodeClientData,&dst, &src);
+    src = p->bytes + p->offset;
+    dst = buf;
+    (*pp->isamb->method->codec.decode)(p->decodeClientData, &dst, &src);
     p->offset = src - (char*) p->bytes;
-    /*
 #if ISAMB_DEBUG
-    (*pp->isamb->method->codec.log_item)(LOG_DEBUG, buf, "read_on_leaf returning 1");
+    (*pp->isamb->method->codec.log_item)(YLOG_DEBUG, buf, "read_on_leaf returning 1");
 #endif
-*/
     pp->returned_numbers++;
     return 1;
 } /* read_on_leaf */
@@ -1426,16 +1364,18 @@ static int isamb_pp_read_on_leaf(ISAMB_PP pp, void *buf)
 static int isamb_pp_forward_on_leaf(ISAMB_PP pp, void *buf, const void *untilbuf)
 { /* forwards on the current leaf, returns 0 if not found */
     int cmp;
-    int skips=0;
-    while (1){
-        if (!isamb_pp_read_on_leaf(pp,buf))
+    int skips = 0;
+    while (1)
+    {
+        if (!isamb_pp_read_on_leaf(pp, buf))
             return 0;
         /* FIXME - this is an extra function call, inline the read? */
-        cmp=(*pp->isamb->method->compare_item)(untilbuf,buf);
-        if (cmp <2){  /* found a good one */
+        cmp=(*pp->isamb->method->compare_item)(untilbuf, buf);
+        if (cmp <pp->scope)
+	{  /* cmp<2  found a good one */
 #if ISAMB_DEBUG
             if (skips)
-                logf(LOG_DEBUG, "isam_pp_fwd_on_leaf skipped %d items",skips);
+                yaz_log(YLOG_DEBUG, "isam_pp_fwd_on_leaf skipped %d items", skips);
 #endif
             pp->returned_numbers++;
             return 1;
@@ -1455,7 +1395,7 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
     const char *src;
     zint item_len;
 #if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_climb_level starting "
+    yaz_log(YLOG_DEBUG, "isamb_pp_climb_level starting "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
@@ -1464,7 +1404,7 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
     if (pp->level==0)
     {
 #if ISAMB_DEBUG
-        logf(LOG_DEBUG,"isamb_pp_climb_level returning 0 at root");
+        yaz_log(YLOG_DEBUG, "isamb_pp_climb_level returning 0 at root");
 #endif
         return 0;
     }
@@ -1472,32 +1412,33 @@ static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos)
     close_block(pp->isamb, pp->block[pp->level]);
     pp->block[pp->level]=0;
     (pp->level)--;
-    p=pp->block[pp->level];
+    p = pp->block[pp->level];
 #if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_climb_level climbed to level %d node %d ofs=%d",
+    yaz_log(YLOG_DEBUG, "isamb_pp_climb_level climbed to level %d node %d ofs=%d",
                     pp->level, p->pos, p->offset);
 #endif
     assert(!p->leaf);
     assert(p->offset <= p->size);
-    if (p->offset == p->size ) {
+    if (p->offset == p->size)
+    {
         /* we came from the last pointer, climb on */
-        if (!isamb_pp_climb_level(pp,pos))
+        if (!isamb_pp_climb_level(pp, pos))
             return 0;
-        p=pp->block[pp->level];
+        p = pp->block[pp->level];
     }
     else
     {
         /* skip the child we just came from */
 #if ISAMB_DEBUG
-        logf(LOG_DEBUG,"isam_pp_climb_level: skipping lev=%d ofs=%d sz=%d", 
+        yaz_log(YLOG_DEBUG, "isam_pp_climb_level: skipping lev=%d ofs=%d sz=%d", 
                         pp->level, p->offset, p->size);
 #endif
-        assert (p->offset < p->size );
-        src=p->bytes + p->offset;
+        assert (p->offset < p->size);
+        src = p->bytes + p->offset;
         decode_ptr(&src, &item_len);
         src += item_len;
         decode_ptr(&src, pos);
-        p->offset=src - (char *)p->bytes;
+        p->offset = src - (char *)p->bytes;
             
     }
     return 1;
@@ -1513,49 +1454,51 @@ static zint isamb_pp_forward_unode(ISAMB_PP pp, zint pos, const void *untilbuf)
   /* parent node, but that gets messy. Presumably the cost is */
   /* pretty low anyway */
     struct ISAMB_block *p = pp->block[pp->level];
-    const char *src=p->bytes + p->offset;
+    const char *src = p->bytes + p->offset;
     zint item_len;
     int cmp;
     zint nxtpos;
 #if ISAMB_DEBUG
-    int skips=0;
-    logf(LOG_DEBUG,"isamb_pp_forward_unode starting "
+    int skips = 0;
+    yaz_log(YLOG_DEBUG, "isamb_pp_forward_unode starting "
                    "at level %d node %d ofs=%di sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
     assert(!p->leaf);
     assert(p->offset <= p->size);
-    if (p->offset == p->size) {
+    if (p->offset == p->size)
+    {
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward_unode returning at end "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward_unode returning at end "
                    "at level %d node %d ofs=%di sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
         return pos; /* already at the end of it */
     }
-    while(p->offset < p->size) {
-        decode_ptr(&src,&item_len);
-        cmp=(*pp->isamb->method->compare_item)(untilbuf,src);
+    while(p->offset < p->size)
+    {
+        decode_ptr(&src, &item_len);
+        cmp=(*pp->isamb->method->compare_item)(untilbuf, src);
         src+=item_len;
-        decode_ptr(&src,&nxtpos);
-        if (cmp<2)
+        decode_ptr(&src, &nxtpos);
+        if (cmp<pp->scope) /* cmp<2 */
         {
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward_unode returning a hit "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward_unode returning a hit "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
             return pos;
         } /* found one */
-        pos=nxtpos;
-        p->offset=src-(char*)p->bytes;
+        pos = nxtpos;
+        p->offset = src-(char*)p->bytes;
         (pp->skipped_nodes[pp->maxlevel - pp->level -1])++;
 #if ISAMB_DEBUG
         skips++;
 #endif
     }
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward_unode returning at tail "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward_unode returning at tail "
                    "at level %d node %d ofs=%d sz=%d skips=%d",
                     pp->level, p->pos, p->offset, p->size, skips);
 #endif
@@ -1569,32 +1512,32 @@ static void isamb_pp_descend_to_leaf(ISAMB_PP pp, ISAMB_P pos, const void *until
     const char *src;
     assert(!p->leaf);
 #if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_descend_to_leaf "
+    yaz_log(YLOG_DEBUG, "isamb_pp_descend_to_leaf "
                    "starting at lev %d node %d ofs=%d lf=%d u=%p", 
                    pp->level, p->pos, p->offset, p->leaf, untilbuf);
 #endif
     if (untilbuf)
-        pos=isamb_pp_forward_unode(pp,pos,untilbuf);
+        pos = isamb_pp_forward_unode(pp, pos, untilbuf);
     ++(pp->level);
     assert(pos);
-    p=open_block(pp->isamb, pos);
+    p = open_block(pp->isamb, pos);
     pp->block[pp->level]=p;
     ++(pp->accessed_nodes[pp->maxlevel-pp->level]);
     ++(pp->no_blocks);
 #if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_descend_to_leaf "
+    yaz_log(YLOG_DEBUG, "isamb_pp_descend_to_leaf "
                    "got lev %d node %d lf=%d", 
                    pp->level, p->pos, p->leaf);
 #endif
     if (p->leaf)
         return;
-    assert (p->offset==0 );
-    src=p->bytes + p->offset;
+    assert (p->offset==0);
+    src = p->bytes + p->offset;
     decode_ptr(&src, &pos);
-    p->offset=src-(char*)p->bytes;
-    isamb_pp_descend_to_leaf(pp,pos,untilbuf);
+    p->offset = src-(char*)p->bytes;
+    isamb_pp_descend_to_leaf(pp, pos, untilbuf);
 #if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_descend_to_leaf "
+    yaz_log(YLOG_DEBUG, "isamb_pp_descend_to_leaf "
                    "returning at lev %d node %d ofs=%d lf=%d", 
                    pp->level, p->pos, p->offset, p->leaf);
 #endif
@@ -1603,9 +1546,9 @@ static void isamb_pp_descend_to_leaf(ISAMB_PP pp, ISAMB_P pos, const void *until
 static int isamb_pp_find_next_leaf(ISAMB_PP pp)
 { /* finds the next leaf by climbing up and down */
     ISAMB_P pos;
-    if (!isamb_pp_climb_level(pp,&pos))
+    if (!isamb_pp_climb_level(pp, &pos))
         return 0;
-    isamb_pp_descend_to_leaf(pp, pos,0);
+    isamb_pp_descend_to_leaf(pp, pos, 0);
     return 1;
 }
 
@@ -1614,20 +1557,20 @@ static int isamb_pp_climb_desc(ISAMB_PP pp,  const void *untilbuf)
     ISAMB_P pos;
 #if ISAMB_DEBUG
     struct ISAMB_block *p = pp->block[pp->level];
-    logf(LOG_DEBUG,"isamb_pp_climb_desc starting "
+    yaz_log(YLOG_DEBUG, "isamb_pp_climb_desc starting "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
-    if (!isamb_pp_climb_level(pp,&pos))
+    if (!isamb_pp_climb_level(pp, &pos))
         return 0;
     /* see if it would pay to climb one higher */
     if (!isamb_pp_on_right_node(pp, pp->level, untilbuf))
-        if (!isamb_pp_climb_level(pp,&pos))
+        if (!isamb_pp_climb_level(pp, &pos))
             return 0;
-    isamb_pp_descend_to_leaf(pp, pos,untilbuf);
+    isamb_pp_descend_to_leaf(pp, pos, untilbuf);
 #if ISAMB_DEBUG
     p = pp->block[pp->level];
-    logf(LOG_DEBUG,"isamb_pp_climb_desc done "
+    yaz_log(YLOG_DEBUG, "isamb_pp_climb_desc done "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
@@ -1639,37 +1582,41 @@ int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf)
 #if ISAMB_DEBUG
     struct ISAMB_block *p = pp->block[pp->level];
     assert(p->leaf);
-    logf(LOG_DEBUG,"isamb_pp_forward starting "
-                   "at level %d node %d ofs=%d sz=%d u=%p",
-                    pp->level, p->pos, p->offset, p->size,untilbuf);
+    yaz_log(YLOG_DEBUG, "isamb_pp_forward starting "
+                   "at level %d node %d ofs=%d sz=%d u=%p sc=%d",
+                    pp->level, p->pos, p->offset, p->size, untilbuf, scope);
 #endif
-    if (untilbuf) {
-        if (isamb_pp_forward_on_leaf( pp, buf, untilbuf)) {
+    if (untilbuf)
+    {
+        if (isamb_pp_forward_on_leaf(pp, buf, untilbuf))
+	{
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward (f) returning (A) "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward (f) returning (A) "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
             return 1;
         }
-        if (! isamb_pp_climb_desc( pp, untilbuf)) {
+        if (! isamb_pp_climb_desc(pp, untilbuf))
+	{
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward (f) returning notfound (B) "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward (f) returning notfound (B) "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
             return 0; /* could not find a leaf */
         }
-        do{
-            if (isamb_pp_forward_on_leaf( pp, buf, untilbuf)) {
+        do {
+            if (isamb_pp_forward_on_leaf(pp, buf, untilbuf))
+	    {
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward (f) returning (C) "
+            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;
             }
-        }while ( isamb_pp_find_next_leaf(pp));
+        } while (isamb_pp_find_next_leaf(pp));
         return 0; /* could not find at all */
     }
     else { /* no untilbuf, a straight read */
@@ -1677,17 +1624,19 @@ int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf)
          * directly into the pp_read */
         /* keeping here now, to keep same
          * interface as the old fwd */
-        if (isamb_pp_read_on_leaf( pp, buf)) {
+        if (isamb_pp_read_on_leaf(pp, buf))
+	{
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward (read) returning (D) "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward (read) returning (D) "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
             return 1;
         }
-        if (isamb_pp_find_next_leaf(pp)) {
+        if (isamb_pp_find_next_leaf(pp))
+	{
 #if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward (read) returning (E) "
+            yaz_log(YLOG_DEBUG, "isamb_pp_forward (read) returning (E) "
                    "at level %d node %d ofs=%d sz=%d",
                     pp->level, p->pos, p->offset, p->size);
 #endif
@@ -1698,301 +1647,9 @@ int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf)
     }
 } /* isam_pp_forward (new version) */
 
-#elif NEW_FORWARD == 0
-
-int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf)
-{
-    /* pseudocode:
-     *   while 1
-     *     while at end of node
-     *       climb higher. If out, return 0
-     *     while not on a leaf (and not at its end)
-     *       decode next
-     *       if cmp
-     *         descend to node
-     *     decode next
-     *     if cmp
-     *       return 1
-     */
-     /* 
-      * The upper nodes consist of a sequence of nodenumbers and keys
-      * When opening a block,  the first node number is read in, and
-      * offset points to the first key, which is the upper limit of keys
-      * in the node just read.
-      */
-    char *dst = buf;
-    const char *src;
-    struct ISAMB_block *p = pp->block[pp->level];
-    int cmp;
-    int item_len;
-    int pos;
-    int nxtpos;
-    int descending=0; /* used to prevent a border condition error */
-    if (!p)
-        return 0;
-#if ISAMB_DEBUG
-    logf(LOG_DEBUG,"isamb_pp_forward starting [%p] p=%d",pp,p->pos);
-    
-    (*pp->isamb->method->codec.log_item)(LOG_DEBUG, untilbuf, "until");
-    (*pp->isamb->method->codec.log_item)(LOG_DEBUG, buf, "buf");
-#endif
-
-    while (1)
-    {
-        while ( (p->offset == p->size) && !descending )
-        {  /* end of this block - climb higher */
-	    assert (p->offset <= p->size);
-#if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward climbing from l=%d",
-                            pp->level);
-#endif
-            if (pp->level == 0)
-            {
-#if ISAMB_DEBUG
-                logf(LOG_DEBUG,"isamb_pp_forward returning 0 at root");
-#endif
-                return 0; /* at end of the root, nothing left */
-            }
-            close_block(pp->isamb, pp->block[pp->level]);
-            pp->block[pp->level]=0;
-            (pp->level)--;
-            p=pp->block[pp->level];
-#if ISAMB_DEBUG
-            logf(LOG_DEBUG,"isamb_pp_forward climbed to node %d off=%d",
-                            p->pos, p->offset);
-#endif
-            assert(!p->leaf);
-            assert(p->offset <= p->size);
-            /* skip the child we have handled */
-            if (p->offset != p->size)
-            { 
-                src = p->bytes + p->offset;
-                decode_ptr(&src, &item_len);
-#if ISAMB_DEBUG		
-		(*pp->isamb->method->codec.log_item)(LOG_DEBUG, src,
-					       " isamb_pp_forward "
-					       "climb skipping old key");
-#endif
-                src += item_len;
-                decode_ptr(&src,&pos);
-                p->offset = src - (char*) p->bytes;
-                break; /* even if this puts us at the end of the block, we
-			  need to descend to the last pos. UGLY coding,
-			  clean up some day */
-            }
-        }
-        if (!p->leaf)
-        { 
-            src = p->bytes + p->offset;
-            if (p->offset == p->size)
-                cmp=-2 ; /* descend to the last node, as we have
-			    no value to cmp */
-            else
-            {
-                decode_ptr(&src, &item_len);
-#if ISAMB_DEBUG
-                logf(LOG_DEBUG,"isamb_pp_forward (B) on a high node. "
-		     "ofs=%d sz=%d nxtpos=%d ",
-                        p->offset,p->size,pos);
-		(*pp->isamb->method->codec.log_item)(LOG_DEBUG, src, "");
-#endif
-                if (untilbuf)
-                    cmp=(*pp->isamb->method->compare_item)(untilbuf,src);
-                else
-                    cmp=-2;
-                src += item_len;
-                decode_ptr(&src,&nxtpos);
-            }
-            if (cmp<2)
-            { 
-#if ISAMB_DEBUG
-                logf(LOG_DEBUG,"isambb_pp_forward descending l=%d p=%d ",
-                            pp->level, pos);
-#endif
-                descending=1; /* prevent climbing for a while */
-                ++(pp->level);
-                p = open_block(pp->isamb,pos);
-                pp->block[pp->level] = p ;
-                pp->total_size += p->size;
-                (pp->accessed_nodes[pp->maxlevel - pp->level])++;
-                pp->no_blocks++;
-                if ( !p->leaf)
-                { /* block starts with a pos */
-                    src = p->bytes + p->offset;
-                    decode_ptr(&src,&pos);
-                    p->offset=src-(char*) p->bytes;
-#if ISAMB_DEBUG
-                    logf(LOG_DEBUG,"isamb_pp_forward: block %d starts with %d",
-                                    p->pos, pos);
-#endif
-                } 
-            } /* descend to the node */
-            else
-            { /* skip the node */
-                p->offset = src - (char*) p->bytes;
-                pos=nxtpos;
-                (pp->skipped_nodes[pp->maxlevel - pp->level -1])++;
-#if ISAMB_DEBUG
-                logf(LOG_DEBUG,
-                    "isamb_pp_forward: skipping block on level %d, noting "
-		     "on %d (%d)",
-                    pp->level, pp->maxlevel - pp->level-1 , 
-                    pp->skipped_nodes[pp->maxlevel - pp->level-1 ]);
-#endif
-                /* 0 is always leafs, 1 is one level above leafs etc, no
-                 * matter how high tree */
-            }
-        } /* not on a leaf */
-        else
-        { /* on a leaf */
-	    if (p->offset == p->size) { 
-		descending = 0;
-	    }
-	    else
-	    {
-		assert (p->offset < p->size);
-		src = p->bytes + p->offset;
-		dst=buf;
-		(*pp->isamb->method->codec.decode)(p->decodeClientData,
-						&dst, &src);
-		p->offset = src - (char*) p->bytes;
-		if (untilbuf)
-		    cmp=(*pp->isamb->method->compare_item)(untilbuf,buf);
-		else
-		    cmp=-2;
-#if ISAMB_DEBUG
-		logf(LOG_DEBUG,"isamb_pp_forward on a leaf. cmp=%d", 
-		     cmp);
-		(*pp->isamb->method->codec.log_item)(LOG_DEBUG, buf, "");
-#endif
-		if (cmp <2)
-		{
-#if ISAMB_DEBUG
-		    if (untilbuf)
-		    {
-			(*pp->isamb->method->codec.log_item)(
-			    LOG_DEBUG, buf,  "isamb_pp_forward returning 1");
-		    }
-		    else
-		    {
-			(*pp->isamb->method->codec.log_item)(
-			    LOG_DEBUG, buf, "isamb_pp_read returning 1 (fwd)");
-		    }
-#endif
-		    pp->returned_numbers++;
-		    return 1;
-		}
-		else
-		    pp->skipped_numbers++;
-	    }
-        } /* leaf */
-    } /* main loop */
-}
-
-#elif NEW_FORWARD == 2
-
-int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilb)
-{
-    char *dst = buf;
-    const char *src;
-    struct ISAMB_block *p = pp->block[pp->level];
-    if (!p)
-        return 0;
-
-again:
-    while (p->offset == p->size)
-    {
-        int pos, item_len;
-        while (p->offset == p->size)
-        {
-            if (pp->level == 0)
-                return 0;
-            close_block (pp->isamb, pp->block[pp->level]);
-            pp->block[pp->level] = 0;
-            (pp->level)--;
-            p = pp->block[pp->level];
-            assert (!p->leaf);  
-        }
-
-	assert(!p->leaf);
-        src = p->bytes + p->offset;
-        
-        decode_ptr (&src, &item_len);
-        src += item_len;
-        decode_ptr (&src, &pos);
-        
-        p->offset = src - (char*) p->bytes;
-
-	src = p->bytes + p->offset;
-
-	while(1)
-	{
-	    if (!untilb || p->offset == p->size)
-		break;
-	    assert(p->offset < p->size);
-	    decode_ptr (&src, &item_len);
-	    if ((*pp->isamb->method->compare_item)(untilb, src) <= 1)
-		break;
-	    src += item_len;
-	    decode_ptr (&src, &pos);
-	    p->offset = src - (char*) p->bytes;
-	}
-
-	pp->level++;
-
-        while (1)
-        {
-            pp->block[pp->level] = p = open_block (pp->isamb, pos);
-
-            pp->total_size += p->size;
-            pp->no_blocks++;
-            
-            if (p->leaf) 
-            {
-                break;
-            }
-	    
-            src = p->bytes + p->offset;
-	    while(1)
-	    {
-		decode_ptr (&src, &pos);
-		p->offset = src - (char*) p->bytes;
-		
-		if (!untilb || p->offset == p->size)
-		    break;
-		assert(p->offset < p->size);
-		decode_ptr (&src, &item_len);
-		if ((*pp->isamb->method->compare_item)(untilb, src) <= 1)
-		    break;
-		src += item_len;
-	    }
-            pp->level++;
-        }
-    }
-    assert (p->offset < p->size);
-    assert (p->leaf);
-    while(1)
-    {
-	char *dst0 = dst;
-        src = p->bytes + p->offset;
-        (*pp->isamb->method->codec.decode)(p->decodeClientData, &dst, &src);
-        p->offset = src - (char*) p->bytes;
-        if (!untilb || (*pp->isamb->method->compare_item)(untilb, dst0) <= 1)
-	    break;
-	dst = dst0;
-	if (p->offset == p->size) goto again;
-    }
-    /* key_logdump_txt(LOG_DEBUG,buf, "isamb_pp_read returning 1"); */
-    return 1;
-}
-
-#endif
-
-void isamb_pp_pos( ISAMB_PP pp, double *current, double *total )
+void isamb_pp_pos(ISAMB_PP pp, double *current, double *total)
 { /* return an estimate of the current position and of the total number of */
   /* occureences in the isam tree, based on the current leaf */
-	/* FIXME - Isam-B ought to know how many we have, so we could return */
-	/* that directly */
     struct ISAMB_block *p = pp->block[pp->level];
     assert(total);
     assert(current);
@@ -2000,9 +1657,8 @@ void isamb_pp_pos( ISAMB_PP pp, double *current, double *total )
 
     *total = pp->block[0]->no_items;
     *current = (double) pp->returned_numbers;
-    /* use the precise number, since we have it! */
 #if ISAMB_DEBUG
-    logf(LOG_LOG, "isamb_pp_pos returning: cur= %0.1f tot=%0.1f rn="
+    yaz_log(YLOG_LOG, "isamb_pp_pos returning: cur= %0.1f tot=%0.1f rn="
 	 ZINT_FORMAT, *current, *total, pp->returned_numbers);
 #endif
 }