From: Heikki Levanto <heikki@indexdata.dk>
Date: Wed, 14 Jul 1999 12:34:43 +0000 (+0000)
Subject: Copied from isamh, starting to change things...
X-Git-Tag: ZEBRA.1.0~74
X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=commitdiff_plain;h=8e5f17591325078343ec4dff4708a12c78863f78

Copied from isamh, starting to change things...
---

diff --git a/include/isamd.h b/include/isamd.h
new file mode 100644
index 0000000..acd2024
--- /dev/null
+++ b/include/isamd.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 1995-1997, Index Data.
+ * See the file LICENSE for details.
+ *
+ * IsamH is a simple ISAM that can only append to the end of the list.
+ * It will need a clean-up process occasionally...  Code stolen from
+ * isamc...
+ * 
+ * Heikki Levanto
+ *
+ * Detailed log at the end of the file
+ *
+ */
+
+#ifndef ISAMH_H
+#define ISAMH_H
+
+#include <bfile.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ISAMH_s *ISAMH;
+typedef int ISAMH_P;
+typedef struct ISAMH_PP_s *ISAMH_PP;
+
+typedef struct ISAMH_filecat_s {  /* filecategories, mostly block sizes */
+    int bsize;         /* block size */
+    int mblocks;       /* maximum keys before switching to larger sizes */
+} *ISAMH_filecat;
+
+typedef struct ISAMH_M_s {
+    ISAMH_filecat filecat;
+
+    int (*compare_item)(const void *a, const void *b);
+
+#define ISAMH_DECODE 0
+#define ISAMH_ENCODE 1
+    void *(*code_start)(int mode);
+    void (*code_stop)(int mode, void *p);
+    void (*code_item)(int mode, void *p, char **dst, char **src);
+    void (*code_reset)(void *p);
+
+    int max_blocks_mem;
+    int debug;
+} *ISAMH_M;
+
+typedef struct ISAMH_I_s {  /* encapsulation of input data */
+    int (*read_item)(void *clientData, char **dst, int *insertMode);
+    void *clientData;
+} *ISAMH_I;
+
+ISAMH_M isamd_getmethod (void);
+
+ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method);
+int isamd_close (ISAMH is);
+ISAMH_P isamd_append (ISAMH is, ISAMH_P pos, ISAMH_I data);
+  /* corresponds to isc_merge */
+  
+  
+ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P pos);
+void isamd_pp_close (ISAMH_PP pp);
+int isamd_read_item (ISAMH_PP pp, char **dst);
+int isamd_pp_read (ISAMH_PP pp, void *buf);
+int isamd_pp_num (ISAMH_PP pp);
+
+int isamd_block_used (ISAMH is, int type);
+int isamd_block_size (ISAMH is, int type);
+
+
+#define isamd_type(x) ((x) & 7)
+#define isamd_block(x) ((x) >> 3)
+#define isamd_addr(blk,typ) (((blk)<<3)+(typ))
+
+void isamd_buildfirstblock(ISAMH_PP pp);
+void isamd_buildlaterblock(ISAMH_PP pp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* ISAMH_H */
+
+
+/*
+ * $Log:  $
+ *
+ */
diff --git a/isamc/isamd-p.h b/isamc/isamd-p.h
new file mode 100644
index 0000000..0c62419
--- /dev/null
+++ b/isamc/isamd-p.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 1995-1996, Index Data.
+ * See the file LICENSE for details.
+ * Heikki Levanto
+ *
+ *
+ */
+
+#include <bfile.h>
+#include <isamd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int lastblock;
+    int freelist;
+} ISAMH_head;
+
+typedef unsigned ISAMH_BLOCK_SIZE;
+
+typedef struct ISAMH_file_s {
+    ISAMH_head head;
+    BFile bf;
+    int head_is_dirty;
+    
+    int no_writes;
+    int no_reads;
+    int no_skip_writes;
+    int no_allocated;
+    int no_released;
+    int no_remap;
+
+    int no_forward;
+    int no_backward;
+    int sum_forward;
+    int sum_backward;
+    int no_next;
+    int no_prev;
+
+    char *alloc_buf;
+    int alloc_entries_num;
+    int alloc_entries_max;
+
+    int fc_max;
+    int *fc_list;
+} *ISAMH_file;
+
+struct ISAMH_s {
+    int no_files;
+    int max_cat;
+  //  char *merge_buf;
+    char *startblock; /* start of the chain, update lastptr and numKeys here */
+    char *lastblock;  /* end of the chain, append here */
+    ISAMH_M method;
+    ISAMH_file files;
+}; 
+
+struct ISAMH_PP_s {
+    char *buf;
+    ISAMH_BLOCK_SIZE offset;
+    ISAMH_BLOCK_SIZE size;
+    int cat;  /* category of this block */
+    int pos;  /* block number of this block */
+    int next; /* number of the next block */
+    ISAMH is;
+    void *decodeClientData;
+    int deleteFlag;
+    int numKeys;
+    ISAMH_BLOCK_SIZE lastblock;  /* last block in chain */
+};
+
+#define ISAMH_BLOCK_OFFSET_N (sizeof(int) +  \
+                              sizeof(ISAMH_BLOCK_SIZE)) 
+/* == 8 */
+#define ISAMH_BLOCK_OFFSET_1 (sizeof(int) + \
+                              sizeof(ISAMH_BLOCK_SIZE) + \
+                              sizeof(int) + \
+                              sizeof(ISAMH_BLOCK_SIZE)) 
+/* == 16 */
+int isamd_alloc_block (ISAMH is, int cat);
+void isamd_release_block (ISAMH is, int cat, int pos);
+int isamd_read_block (ISAMH is, int cat, int pos, char *dst);
+int isamd_write_block (ISAMH is, int cat, int pos, char *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+/*
+ * $Log: isamd-p.h,v $
+ * Revision 1.1  1999-07-14 12:34:43  heikki
+ * Copied from isamh, starting to change things...
+ *
+ *
+ */
\ No newline at end of file
diff --git a/isamc/isamd.c b/isamc/isamd.c
new file mode 100644
index 0000000..5134f4b
--- /dev/null
+++ b/isamc/isamd.c
@@ -0,0 +1,702 @@
+/*
+ * Copyright (c) 1995-1998, Index Data.
+ * See the file LICENSE for details.
+ * Heikki Levanto
+ * 
+ * Isamd - isam with diffs 
+ *
+ * todo
+ *   most of it, this is just a copy of isamh
+ *
+ */
+
+
+
+
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <log.h>
+#include "isamd-p.h"
+
+#include "../index/index.h" /* for dump */
+
+static void flush_block (ISAMH is, int cat);
+static void release_fc (ISAMH is, int cat);
+static void init_fc (ISAMH is, int cat);
+
+#define ISAMH_FREELIST_CHUNK 1
+
+#define SMALL_TEST 1
+
+ISAMH_M isamd_getmethod (void)
+{
+    static struct ISAMH_filecat_s def_cat[] = {
+#if SMALL_TEST
+/*        blocksz,   max keys before switching size */
+  /*      {    32,  40 }, */
+	{   128,   0 },
+#else
+        {    24,   40 },
+        {  2048, 2048 },
+        { 16384,    0  },
+
+#endif 
+#ifdef OLDVALUES
+        {    24,   40 },
+	{   128,  256 },
+        {   512, 1024 },
+        {  2048, 4096 },
+        {  8192,16384 },
+        { 32768,   0  },
+
+#endif
+/* assume about 2 bytes per pointer, when compressed. The head uses */
+/* 16 bytes, and other blocks use 8 for header info... If you want 3 */
+/* blocks of 32 bytes, say max 16+24+24 = 64 keys */
+
+    };
+    ISAMH_M m = (ISAMH_M) xmalloc (sizeof(*m));
+    m->filecat = def_cat;
+
+    m->code_start = NULL;
+    m->code_item = NULL;
+    m->code_stop = NULL;
+    m->code_reset = NULL;
+
+    m->compare_item = NULL;
+
+    m->debug = 1;
+
+    m->max_blocks_mem = 10;
+
+    return m;
+}
+
+
+
+ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method)
+{
+    ISAMH is;
+    ISAMH_filecat filecat;
+    int i = 0;
+    int max_buf_size = 0;
+
+    is = (ISAMH) xmalloc (sizeof(*is));
+
+    is->method = (ISAMH_M) xmalloc (sizeof(*is->method));
+    memcpy (is->method, method, sizeof(*method));
+    filecat = is->method->filecat;
+    assert (filecat);
+
+    /* determine number of block categories */
+    if (is->method->debug)
+        logf (LOG_LOG, "isc: bsize  maxkeys");
+    do
+    {
+        if (is->method->debug)
+            logf (LOG_LOG, "isc:%6d %6d",
+                  filecat[i].bsize, filecat[i].mblocks);
+        if (max_buf_size < filecat[i].bsize)
+            max_buf_size = filecat[i].bsize;
+    } while (filecat[i++].mblocks);
+    is->no_files = i;
+    is->max_cat = --i;
+#ifdef SKIPTHIS
+    /* max_buf_size is the larget buffer to be used during merge */
+    max_buf_size = (1 + max_buf_size / filecat[i].bsize) * filecat[i].bsize;
+    if (max_buf_size < (1+is->method->max_blocks_mem) * filecat[i].bsize)
+        max_buf_size = (1+is->method->max_blocks_mem) * filecat[i].bsize;
+#endif
+
+    if (is->method->debug)
+        logf (LOG_LOG, "isc: max_buf_size %d", max_buf_size);
+    
+    assert (is->no_files > 0);
+    is->files = (ISAMH_file) xmalloc (sizeof(*is->files)*is->no_files);
+    if (writeflag)
+    {
+#ifdef SKIPTHIS
+        is->merge_buf = (char *) xmalloc (max_buf_size+256);
+	memset (is->merge_buf, 0, max_buf_size+256);
+#else
+        is->startblock = (char *) xmalloc (max_buf_size+256);
+	memset (is->startblock, 0, max_buf_size+256);
+        is->lastblock = (char *) xmalloc (max_buf_size+256);
+	memset (is->lastblock, 0, max_buf_size+256);
+	/* The spare 256 bytes should not be needed! */
+#endif
+    }
+    else
+        is->startblock = is->lastblock = NULL;
+
+    for (i = 0; i<is->no_files; i++)
+    {
+        char fname[512];
+
+        sprintf (fname, "%s%c", name, i+'A');
+        is->files[i].bf = bf_open (bfs, fname, is->method->filecat[i].bsize,
+                                   writeflag);
+        is->files[i].head_is_dirty = 0;
+        if (!bf_read (is->files[i].bf, 0, 0, sizeof(ISAMH_head),
+                     &is->files[i].head))
+        {
+            is->files[i].head.lastblock = 1;
+            is->files[i].head.freelist = 0;
+        }
+	is->files[i].alloc_entries_num = 0;
+	is->files[i].alloc_entries_max =
+	    is->method->filecat[i].bsize / sizeof(int) - 1;
+	is->files[i].alloc_buf = (char *)
+	    xmalloc (is->method->filecat[i].bsize);
+        is->files[i].no_writes = 0;
+        is->files[i].no_reads = 0;
+        is->files[i].no_skip_writes = 0;
+        is->files[i].no_allocated = 0;
+        is->files[i].no_released = 0;
+        is->files[i].no_remap = 0;
+	is->files[i].no_forward = 0;
+	is->files[i].no_backward = 0;
+	is->files[i].sum_forward = 0;
+	is->files[i].sum_backward = 0;
+	is->files[i].no_next = 0;
+	is->files[i].no_prev = 0;
+
+        init_fc (is, i);
+    }
+    return is;
+}
+
+int isamd_block_used (ISAMH is, int type)
+{
+    if (type < 0 || type >= is->no_files)
+	return -1;
+    return is->files[type].head.lastblock-1;
+}
+
+int isamd_block_size (ISAMH is, int type)
+{
+    ISAMH_filecat filecat = is->method->filecat;
+    if (type < 0 || type >= is->no_files)
+	return -1;
+    return filecat[type].bsize;
+}
+
+int isamd_close (ISAMH is)
+{
+    int i;
+
+    if (is->method->debug)
+    {
+	logf (LOG_LOG, "isc:    next    forw   mid-f    prev   backw   mid-b");
+	for (i = 0; i<is->no_files; i++)
+	    logf (LOG_LOG, "isc:%8d%8d%8.1f%8d%8d%8.1f",
+		  is->files[i].no_next,
+		  is->files[i].no_forward,
+		  is->files[i].no_forward ?
+		  (double) is->files[i].sum_forward/is->files[i].no_forward
+		  : 0.0,
+		  is->files[i].no_prev,
+		  is->files[i].no_backward,
+		  is->files[i].no_backward ?
+		  (double) is->files[i].sum_backward/is->files[i].no_backward
+		  : 0.0);
+    }
+    if (is->method->debug)
+        logf (LOG_LOG, "isc:  writes   reads skipped   alloc released  remap");
+    for (i = 0; i<is->no_files; i++)
+    {
+        release_fc (is, i);
+        assert (is->files[i].bf);
+        if (is->files[i].head_is_dirty)
+            bf_write (is->files[i].bf, 0, 0, sizeof(ISAMH_head),
+                 &is->files[i].head);
+        if (is->method->debug)
+            logf (LOG_LOG, "isc:%8d%8d%8d%8d%8d%8d",
+                  is->files[i].no_writes,
+                  is->files[i].no_reads,
+                  is->files[i].no_skip_writes,
+                  is->files[i].no_allocated,
+                  is->files[i].no_released,
+                  is->files[i].no_remap);
+        xfree (is->files[i].fc_list);
+	flush_block (is, i);
+        bf_close (is->files[i].bf);
+    }
+    xfree (is->files);
+    xfree (is->startblock);
+    xfree (is->lastblock);
+    xfree (is->method);
+    xfree (is);
+    return 0;
+}
+
+int isamd_read_block (ISAMH is, int cat, int pos, char *dst)
+{
+    ++(is->files[cat].no_reads);
+    return bf_read (is->files[cat].bf, pos, 0, 0, dst);
+}
+
+int isamd_write_block (ISAMH is, int cat, int pos, char *src)
+{
+    ++(is->files[cat].no_writes);
+    if (is->method->debug > 2)
+        logf (LOG_LOG, "isc: write_block %d %d", cat, pos);
+    return bf_write (is->files[cat].bf, pos, 0, 0, src);
+}
+
+int isamd_write_dblock (ISAMH is, int cat, int pos, char *src,
+                      int nextpos, int offset)
+{
+    ISAMH_BLOCK_SIZE size = offset + ISAMH_BLOCK_OFFSET_N;
+    if (is->method->debug > 2)
+        logf (LOG_LOG, "isc: write_dblock. size=%d nextpos=%d",
+              (int) size, nextpos);
+    src -= ISAMH_BLOCK_OFFSET_N;
+    memcpy (src, &nextpos, sizeof(int));
+    memcpy (src + sizeof(int), &size, sizeof(size));
+    return isamd_write_block (is, cat, pos, src);
+}
+
+#if ISAMH_FREELIST_CHUNK
+static void flush_block (ISAMH is, int cat)
+{
+    char *abuf = is->files[cat].alloc_buf;
+    int block = is->files[cat].head.freelist;
+    if (block && is->files[cat].alloc_entries_num)
+    {
+	memcpy (abuf, &is->files[cat].alloc_entries_num, sizeof(int));
+	bf_write (is->files[cat].bf, block, 0, 0, abuf);
+	is->files[cat].alloc_entries_num = 0;
+    }
+    xfree (abuf);
+}
+
+static int alloc_block (ISAMH is, int cat)
+{
+    int block = is->files[cat].head.freelist;
+    char *abuf = is->files[cat].alloc_buf;
+
+    (is->files[cat].no_allocated)++;
+
+    if (!block)
+    {
+        block = (is->files[cat].head.lastblock)++;   /* no free list */
+	is->files[cat].head_is_dirty = 1;
+    }
+    else
+    {
+	if (!is->files[cat].alloc_entries_num) /* read first time */
+	{
+	    bf_read (is->files[cat].bf, block, 0, 0, abuf);
+	    memcpy (&is->files[cat].alloc_entries_num, abuf,
+		    sizeof(is->files[cat].alloc_entries_num));
+	    assert (is->files[cat].alloc_entries_num > 0);
+	}
+	/* have some free blocks now */
+	assert (is->files[cat].alloc_entries_num > 0);
+	is->files[cat].alloc_entries_num--;
+	if (!is->files[cat].alloc_entries_num)  /* last one in block? */
+	{
+	    memcpy (&is->files[cat].head.freelist, abuf + sizeof(int),
+		    sizeof(int));
+	    is->files[cat].head_is_dirty = 1;
+
+	    if (is->files[cat].head.freelist)
+	    {
+		bf_read (is->files[cat].bf, is->files[cat].head.freelist,
+			 0, 0, abuf);
+		memcpy (&is->files[cat].alloc_entries_num, abuf,
+			sizeof(is->files[cat].alloc_entries_num));
+		assert (is->files[cat].alloc_entries_num);
+	    }
+	}
+	else
+	    memcpy (&block, abuf + sizeof(int) + sizeof(int) *
+		    is->files[cat].alloc_entries_num, sizeof(int));
+    }
+    return block;
+}
+
+static void release_block (ISAMH is, int cat, int pos)
+{
+    char *abuf = is->files[cat].alloc_buf;
+    int block = is->files[cat].head.freelist;
+
+    (is->files[cat].no_released)++;
+
+    if (block && !is->files[cat].alloc_entries_num) /* must read block */
+    {
+	bf_read (is->files[cat].bf, block, 0, 0, abuf);
+	memcpy (&is->files[cat].alloc_entries_num, abuf,
+		sizeof(is->files[cat].alloc_entries_num));
+	assert (is->files[cat].alloc_entries_num > 0);
+    }
+    assert (is->files[cat].alloc_entries_num <= is->files[cat].alloc_entries_max);
+    if (is->files[cat].alloc_entries_num == is->files[cat].alloc_entries_max)
+    {
+	assert (block);
+	memcpy (abuf, &is->files[cat].alloc_entries_num, sizeof(int));
+	bf_write (is->files[cat].bf, block, 0, 0, abuf);
+	is->files[cat].alloc_entries_num = 0;
+    }
+    if (!is->files[cat].alloc_entries_num) /* make new buffer? */
+    {
+	memcpy (abuf + sizeof(int), &block, sizeof(int));
+	is->files[cat].head.freelist = pos;
+	is->files[cat].head_is_dirty = 1; 
+    }
+    else
+    {
+	memcpy (abuf + sizeof(int) +
+		is->files[cat].alloc_entries_num*sizeof(int),
+		&pos, sizeof(int));
+    }
+    is->files[cat].alloc_entries_num++;
+}
+#else
+static void flush_block (ISAMH is, int cat)
+{
+    char *abuf = is->files[cat].alloc_buf;
+    xfree (abuf);
+}
+
+static int alloc_block (ISAMH is, int cat)
+{
+    int block;
+    char buf[sizeof(int)];
+
+    is->files[cat].head_is_dirty = 1;
+    (is->files[cat].no_allocated)++;
+    if ((block = is->files[cat].head.freelist))
+    {
+        bf_read (is->files[cat].bf, block, 0, sizeof(int), buf);
+        memcpy (&is->files[cat].head.freelist, buf, sizeof(int));
+    }
+    else
+        block = (is->files[cat].head.lastblock)++;
+    return block;
+}
+
+static void release_block (ISAMH is, int cat, int pos)
+{
+    char buf[sizeof(int)];
+   
+    (is->files[cat].no_released)++;
+    is->files[cat].head_is_dirty = 1; 
+    memcpy (buf, &is->files[cat].head.freelist, sizeof(int));
+    is->files[cat].head.freelist = pos;
+    bf_write (is->files[cat].bf, pos, 0, sizeof(int), buf);
+}
+#endif
+
+int isamd_alloc_block (ISAMH is, int cat)
+{
+    int block = 0;
+
+    if (is->files[cat].fc_list)
+    {
+        int j, nb;
+        for (j = 0; j < is->files[cat].fc_max; j++)
+            if ((nb = is->files[cat].fc_list[j]) && (!block || nb < block))
+            {
+                is->files[cat].fc_list[j] = 0;
+		block = nb;
+                break;
+            }
+    }
+    if (!block)
+        block = alloc_block (is, cat);
+    if (is->method->debug > 3)
+        logf (LOG_LOG, "isc: alloc_block in cat %d: %d", cat, block);
+    return block;
+}
+
+void isamd_release_block (ISAMH is, int cat, int pos)
+{
+    if (is->method->debug > 3)
+        logf (LOG_LOG, "isc: release_block in cat %d: %d", cat, pos);
+    if (is->files[cat].fc_list)
+    {
+        int j;
+        for (j = 0; j<is->files[cat].fc_max; j++)
+            if (!is->files[cat].fc_list[j])
+            {
+                is->files[cat].fc_list[j] = pos;
+                return;
+            }
+    }
+    release_block (is, cat, pos);
+}
+
+static void init_fc (ISAMH is, int cat)
+{
+    int j = 100;
+        
+    is->files[cat].fc_max = j;
+    is->files[cat].fc_list = (int *)
+	xmalloc (sizeof(*is->files[0].fc_list) * j);
+    while (--j >= 0)
+        is->files[cat].fc_list[j] = 0;
+}
+
+static void release_fc (ISAMH is, int cat)
+{
+    int b, j = is->files[cat].fc_max;
+
+    while (--j >= 0)
+        if ((b = is->files[cat].fc_list[j]))
+        {
+            release_block (is, cat, b);
+            is->files[cat].fc_list[j] = 0;
+        }
+}
+
+void isamd_pp_close (ISAMH_PP pp)
+{
+    ISAMH is = pp->is;
+
+    (*is->method->code_stop)(ISAMH_DECODE, pp->decodeClientData);
+    xfree (pp->buf);
+    xfree (pp);
+}
+
+ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P ipos)
+{
+    ISAMH_PP pp = (ISAMH_PP) xmalloc (sizeof(*pp));
+    char *src;
+   
+    pp->cat = isamd_type(ipos);
+    pp->pos = isamd_block(ipos); 
+
+    src = pp->buf = (char *) xmalloc (is->method->filecat[pp->cat].bsize);
+
+    pp->next = 0;
+    pp->size = 0;
+    pp->offset = 0;
+    pp->is = is;
+    pp->decodeClientData = (*is->method->code_start)(ISAMH_DECODE);
+    pp->deleteFlag = 0;
+    pp->numKeys = 0;
+    pp->lastblock=0;
+    
+    if (pp->pos)
+    {
+        src = pp->buf;
+        isamd_read_block (is, pp->cat, pp->pos, src);
+        memcpy (&pp->next, src, sizeof(pp->next));
+        src += sizeof(pp->next);
+        memcpy (&pp->size, src, sizeof(pp->size));
+        src += sizeof(pp->size);
+        memcpy (&pp->numKeys, src, sizeof(pp->numKeys));
+        src += sizeof(pp->numKeys);
+        memcpy (&pp->lastblock, src, sizeof(pp->lastblock));
+        src += sizeof(pp->lastblock);
+        assert (pp->next != pp->pos);
+        pp->offset = src - pp->buf; 
+        assert (pp->offset == ISAMH_BLOCK_OFFSET_1);
+        if (is->method->debug > 2)
+            logf (LOG_LOG, "isamd_pp_open sz=%d c=%d p=%d n=%d",
+                 pp->size, pp->cat, pp->pos, isamd_block(pp->next));
+    }
+    return pp;
+}
+
+
+
+void isamd_buildfirstblock(ISAMH_PP pp){
+  char *dst=pp->buf;
+  assert(pp->buf);
+  assert(pp->next != pp->pos); 
+  memcpy(dst, &pp->next, sizeof(pp->next) );
+  dst += sizeof(pp->next);
+  memcpy(dst, &pp->size,sizeof(pp->size));
+  dst += sizeof(pp->size);
+  memcpy(dst, &pp->numKeys, sizeof(pp->numKeys));
+  dst += sizeof(pp->numKeys);
+  memcpy(dst, &pp->lastblock, sizeof(pp->lastblock));
+  dst += sizeof(pp->lastblock);  
+  assert (dst - pp->buf  == ISAMH_BLOCK_OFFSET_1);
+  if (pp->is->method->debug > 2)
+     logf (LOG_LOG, "isamd: first: sz=%d  p=%d/%d>%d/%d>%d/%d nk=%d",
+           pp->size, 
+           pp->pos, pp->cat, 
+           isamd_block(pp->next), isamd_type(pp->next),
+           isamd_block(pp->lastblock), isamd_type(pp->lastblock),
+           pp->numKeys);
+}
+
+void isamd_buildlaterblock(ISAMH_PP pp){
+  char *dst=pp->buf;
+  assert(pp->buf);
+  assert(pp->next != isamd_addr(pp->pos,pp->cat)); 
+  memcpy(dst, &pp->next, sizeof(pp->next) );
+  dst += sizeof(pp->next);
+  memcpy(dst, &pp->size,sizeof(pp->size));
+  dst += sizeof(pp->size);
+  assert (dst - pp->buf  == ISAMH_BLOCK_OFFSET_N);
+  if (pp->is->method->debug > 2)
+     logf (LOG_LOG, "isamd: l8r: sz=%d  p=%d/%d>%d/%d",
+           pp->size, 
+           pp->pos, pp->cat, 
+           isamd_block(pp->next), isamd_type(pp->next) );
+}
+
+
+
+/* returns non-zero if item could be read; 0 otherwise */
+int isamd_pp_read (ISAMH_PP pp, void *buf)
+{
+    return isamd_read_item (pp, (char **) &buf);
+}
+
+/* read one item from file - decode and store it in *dst.
+   Returns
+     0 if end-of-file
+     1 if item could be read ok and NO boundary
+     2 if item could be read ok and boundary */
+int isamd_read_item (ISAMH_PP pp, char **dst)
+{
+    ISAMH is = pp->is;
+    char *src = pp->buf + pp->offset;
+    int newcat;
+
+    if (pp->offset >= pp->size)
+    {
+	if (!pp->next)
+	{
+	    pp->pos = 0;
+	    return 0; /* end of file */
+	}
+	if (pp->next > pp->pos)
+	{
+	    if (pp->next == pp->pos + 1)
+		is->files[pp->cat].no_next++;
+	    else
+	    {
+		is->files[pp->cat].no_forward++;
+		is->files[pp->cat].sum_forward += pp->next - pp->pos;
+	    }
+	}
+	else
+	{
+	    if (pp->next + 1 == pp->pos)
+		is->files[pp->cat].no_prev++;
+	    else
+	    {
+		is->files[pp->cat].no_backward++;
+		is->files[pp->cat].sum_backward += pp->pos - pp->next;
+	    }
+	}
+	/* out new block position */
+	newcat = isamd_type(pp->next);
+	if (pp->cat != newcat ) {
+	  pp->buf = xrealloc(pp->buf, is->method->filecat[newcat].bsize);
+	}
+        pp->pos = isamd_block(pp->next);
+        pp->cat = isamd_type(pp->next);
+        
+        src = pp->buf;
+	/* read block and save 'next' and 'size' entry */
+        isamd_read_block (is, pp->cat, pp->pos, src);
+        memcpy (&pp->next, src, sizeof(pp->next));
+        src += sizeof(pp->next);
+        memcpy (&pp->size, src, sizeof(pp->size));
+        src += sizeof(pp->size);
+        /* assume block is non-empty */
+        assert (src - pp->buf == ISAMH_BLOCK_OFFSET_N);
+        assert (pp->next != isamd_addr(pp->pos,pp->cat));
+        if (pp->deleteFlag)
+            isamd_release_block (is, pp->cat, pp->pos);
+        (*is->method->code_reset)(pp->decodeClientData);
+        (*is->method->code_item)(ISAMH_DECODE, pp->decodeClientData, dst, &src);
+        pp->offset = src - pp->buf; 
+        if (is->method->debug > 2)
+            logf (LOG_LOG, "isc: read_block size=%d %d %d next=%d",
+                 pp->size, pp->cat, pp->pos, pp->next);
+        return 2;
+    }
+    (*is->method->code_item)(ISAMH_DECODE, pp->decodeClientData, dst, &src);
+    pp->offset = src - pp->buf; 
+    return 1;
+}
+
+int isamd_pp_num (ISAMH_PP pp)
+{
+    return pp->numKeys;
+}
+
+static char *hexdump(unsigned char *p, int len, char *buff) {
+  static char localbuff[128];
+  char bytebuff[8];
+  if (!buff) buff=localbuff;
+  *buff='\0';
+  while (len--) {
+    sprintf(bytebuff,"%02x",*p);
+    p++;
+    strcat(buff,bytebuff);
+    if (len) strcat(buff," ");
+  }
+  return buff;
+}
+
+
+void isamd_pp_dump (ISAMH is, ISAMH_P ipos)
+{
+  ISAMH_PP pp;
+  ISAMH_P oldaddr=0;
+  struct it_key key;
+  int i,n;
+  int occur =0;
+  int oldoffs;
+  char hexbuff[64];
+  
+  logf(LOG_LOG,"dumping isamd block %d (%d:%d)",
+                  (int)ipos, isamd_type(ipos), isamd_block(ipos) );
+  pp=isamd_pp_open(is,ipos);
+  logf(LOG_LOG,"numKeys=%d, last=%d (%d:%d) ofs=%d ",
+       pp->numKeys, 
+       pp->lastblock, 
+       isamd_type(pp->lastblock), isamd_block(pp->lastblock),
+       pp->offset);
+  oldoffs= pp->offset;
+  while(isamd_pp_read(pp, &key))
+  {
+     if (oldaddr != isamd_addr(pp->pos,pp->cat) )
+     {
+        oldaddr = isamd_addr(pp->pos,pp->cat); 
+        logf(LOG_LOG,"block %d (%d:%d) sz=%d nx=%d (%d:%d) ofs=%d",
+                  isamd_addr(pp->pos,pp->cat), 
+                  pp->cat, pp->pos, pp->size,
+                  pp->next, isamd_type(pp->next), isamd_block(pp->next),
+                  pp->offset);
+        i=0;      
+        while (i<pp->size) {
+          n=pp->size-i;
+          if (n>8) n=8;
+          logf(LOG_LOG,"  %05x: %s",i,hexdump(pp->buf+i,n,hexbuff));
+          i+=n;
+        }
+        if (oldoffs >  ISAMH_BLOCK_OFFSET_N)
+           oldoffs=ISAMH_BLOCK_OFFSET_N;
+     } /* new block */
+     occur++;
+     logf (LOG_LOG,"    got %d:%d=%x:%x from %s at %d=%x",
+      	          key.sysno, key.seqno,
+	          key.sysno, key.seqno,
+	          hexdump(pp->buf+oldoffs, pp->offset-oldoffs, hexbuff),
+	          oldoffs, oldoffs);
+     oldoffs = pp->offset;
+  }
+  isamd_pp_close(pp);
+} /* dump */
+
+/*
+ * $Log: isamd.c,v $
+ * Revision 1.1  1999-07-14 12:34:43  heikki
+ * Copied from isamh, starting to change things...
+ *
+ *
+ */
\ No newline at end of file