From: Heikki Levanto <heikki@indexdata.dk>
Date: Tue, 31 Aug 2004 10:43:35 +0000 (+0000)
Subject: Major restructuring in rsets.
X-Git-Tag: snippet.version.1~377
X-Git-Url: http://git.indexdata.com/?a=commitdiff_plain;ds=sidebyside;h=70effaa5a4a18f1bef9c6111dc082bb8714e4c19;p=idzebra-moved-to-github.git

Major restructuring in rsets.
---

diff --git a/include/rset.h b/include/rset.h
index 2add4a1..4517ba9 100644
--- a/include/rset.h
+++ b/include/rset.h
@@ -1,4 +1,4 @@
-/* $Id: rset.h,v 1.31 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rset.h,v 1.32 2004-08-31 10:43:35 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
    Index Data Aps
 
@@ -31,18 +31,25 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 extern "C" {
 #endif
 
-typedef void *RSFD;       /* Rset "file descriptor" */
-typedef struct rset *RSET;
+typedef struct rsfd *RSFD; /* Rset "file descriptor" */
+typedef struct rset *RSET; /* Result set */
+
+struct rsfd {  /* the stuff common to all rsfd's. */
+    RSET rset;  /* ptr to the rset this FD is opened to */
+    void *priv; /* private parameters for this type */
+    RSFD next;  /* to keep lists of used/free rsfd's */
+};
+
 
 struct rset_control
 {
     char *desc; /* text description of set type (for debugging) */
-/* void *(*f_create)(RSET ct, const struct rset_control *sel, void *parms); */
+/* RSET rs_something_create(const struct rset_control *sel, ...); */
+    void (*f_delete)(RSET ct);
     RSFD (*f_open)(RSET ct, int wflag);
     void (*f_close)(RSFD rfd);
-    void (*f_delete)(RSET ct);
     void (*f_rewind)(RSFD rfd);
-    int (*f_forward)(RSET ct, RSFD rfd, void *buf,
+    int (*f_forward)(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2), 
                      const void *untilbuf);
     void (*f_pos)(RSFD rfd, double *current, double *total);
@@ -51,10 +58,9 @@ struct rset_control
     int (*f_write)(RSFD rfd, const void *buf);
 };
 
-int rset_default_forward(RSET ct, RSFD rfd, void *buf, 
+int rset_default_forward(RSFD rfd, void *buf, 
                      int (*cmpfunc)(const void *p1, const void *p2), 
                      const void *untilbuf);
-void rset_default_pos(RSFD rfd, double *current, double *total);
 
 
 typedef struct rset
@@ -65,46 +71,46 @@ typedef struct rset
     NMEM nmem;    /* nibble memory for various allocs */
     char my_nmem; /* Should the nmem be destroyed with the rset?  */
                   /* 1 if created with it, 0 if passed from above */
+    RSFD free_list; /* all rfd's allocated but not currently in use */
 } rset;
 /* rset is a "virtual base class", which will never exist on its own */
 /* all instances are rsets of some specific type, like rsisamb, or rsbool */
 /* They keep their own stuff behind the priv pointer. */
 
-#define RSETF_READ       0
-#define RSETF_WRITE      1
+RSFD rfd_create_base(RSET rs);
+void rfd_delete_base(RSFD rfd);
 
 RSET rset_create_base(const struct rset_control *sel, NMEM nmem);
-
-RSET rset_create_OLD(const struct rset_control *sel, void *parms); 
-/* parameters? */
-
 void rset_delete(RSET rs);
-
 RSET rset_dup (RSET rs);
 
 
+#define RSETF_READ       0
+#define RSETF_WRITE      1
 /* RSFD rset_open(RSET rs, int wflag); */
 #define rset_open(rs, wflag) (*(rs)->control->f_open)((rs), (wflag))
 
-/* void rset_close(RSET rs); */
-#define rset_close(rs, rfd) (*(rs)->control->f_close)(rfd)
+/* void rset_close(RSFD rfd); */
+#define rset_close(rfd) (*(rfd)->rset->control->f_close)(rfd)
 
-/* void rset_rewind(RSET rs); */
-#define rset_rewind(rs, rfd) (*(rs)->control->f_rewind)((rfd))
+/* void rset_rewind(RSFD rfd); */
+#define rset_rewind(rfd) (*(rfd)->rset->control->f_rewind)((rfd))
 
-/* int rset_forward(RSET rs, void *buf, void *untilbuf); */
-#define rset_forward(rs, fd, buf, cmpfunc, untilbuf) \
-    (*(rs)->control->f_forward)((rs), (fd), (buf), (cmpfunc), (untilbuf))
+/* int rset_forward(RSFD rfd, void *buf, void *untilbuf); */
+#define rset_forward(rfd, buf, cmpfunc, untilbuf) \
+    (*(rfd)->rset->control->f_forward)((rfd),(buf),(cmpfunc),(untilbuf))
+/*FIXME - get rid of the cmp function here, keep it in a general */
+/*        key_control block */
 
-/* int rset_pos(RSET rs, RSFD fd, double *current, double *total); */
-#define rset_pos(rs,fd,cur,tot) \
-    (*(rs)->control->f_pos)( (fd),(cur),(tot))
+/* int rset_pos(RSFD fd, double *current, double *total); */
+#define rset_pos(rfd,cur,tot) \
+    (*(rfd)->rset->control->f_pos)( (rfd),(cur),(tot))
 
-/* int rset_read(RSET rs, void *buf); */
-#define rset_read(rs, fd, buf) (*(rs)->control->f_read)((fd), (buf))
+/* int rset_read(RSFD rfd, void *buf); */
+#define rset_read(rfd, buf) (*(rfd)->rset->control->f_read)((rfd), (buf))
 
-/* int rset_write(RSET rs, const void *buf); */
-#define rset_write(rs, fd, buf) (*(rs)->control->f_write)((fd), (buf))
+/* int rset_write(RSFD rfd, const void *buf); */
+#define rset_write(rfd, buf) (*(rfd)->rset->control->f_write)((rfd), (buf))
 
 /* int rset_type (RSET) */
 #define rset_type(rs) ((rs)->control->desc)
diff --git a/index/trunc.c b/index/trunc.c
index 95f297f..5cc49f0 100644
--- a/index/trunc.c
+++ b/index/trunc.c
@@ -1,4 +1,4 @@
-/* $Id: trunc.c,v 1.39 2004-08-25 09:18:06 adam Exp $
+/* $Id: trunc.c,v 1.40 2004-08-31 10:43:35 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -179,11 +179,11 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
         for (i = rscur; --i >= 0; )
         {
             rsfd[i] = rset_open (rset[i], RSETF_READ);
-            if (rset_read (rset[i], rsfd[i], ti->tmpbuf))
+            if (rset_read(rsfd[i], ti->tmpbuf))
                 heap_insert (ti, ti->tmpbuf, i);
             else
             {
-                rset_close (rset[i], rsfd[i]);
+                rset_close (rsfd[i]);
                 rset_delete (rset[i]);
             }
         }
@@ -191,15 +191,15 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
         {
             int n = ti->indx[ti->ptr[1]];
 
-            rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+            rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
             nn++;
 
             while (1)
             {
-                if (!rset_read (rset[n], rsfd[n], ti->tmpbuf))
+                if (!rset_read (rsfd[n], ti->tmpbuf))
                 {
                     heap_delete (ti);
-                    rset_close (rset[n], rsfd[n]);
+                    rset_close (rsfd[n]);
                     rset_delete (rset[n]);
                     break;
                 }
@@ -237,7 +237,7 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
         {
             int n = ti->indx[ti->ptr[1]];
 
-            rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+            rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
             nn++;
             if (preserve_position)
             {
@@ -292,7 +292,7 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
         {
             int n = ti->indx[ti->ptr[1]];
 
-            rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+            rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
             nn++;
             while (1)
             {
@@ -337,7 +337,7 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
         {
             int n = ti->indx[ti->ptr[1]];
 
-            rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+            rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
             nn++;
 
             if (preserve_position)
@@ -373,7 +373,7 @@ static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
     else
         logf (LOG_WARN, "Unknown isam set in rset_trunc_r");
 
-    rset_close (result, result_rsfd);
+    rset_close (result_rsfd);
     return result;
 }
 
diff --git a/index/zrpn.c b/index/zrpn.c
index 83ad083..fc43193 100644
--- a/index/zrpn.c
+++ b/index/zrpn.c
@@ -1,4 +1,4 @@
-/* $Id: zrpn.c,v 1.146 2004-08-30 12:32:24 heikki Exp $
+/* $Id: zrpn.c,v 1.147 2004-08-31 10:43:35 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -1797,8 +1797,8 @@ static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     if (key.sysno <= 0)
         key.sysno = 1;
 #endif
-    rset_write (result, rsfd, &key);
-    rset_close (result, rsfd);
+    rset_write (rsfd, &key);
+    rset_close (rsfd);
     return result;
 }
 
@@ -2461,7 +2461,7 @@ static void count_set (RSET r, int *count)
 
     *count = 0;
     rfd = rset_open (r, RSETF_READ);
-    while (rset_read (r, rfd, &key))
+    while (rset_read (rfd, &key))
     {
 #if IT_KEY_NEW
         if (key.mem[0] != psysno)
@@ -2478,7 +2478,7 @@ static void count_set (RSET r, int *count)
 #endif
         kno++;
     }
-    rset_close (r, rfd);
+    rset_close (rfd);
     logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
 }
 
diff --git a/index/zsets.c b/index/zsets.c
index aa2d16d..91d3627 100644
--- a/index/zsets.c
+++ b/index/zsets.c
@@ -1,4 +1,4 @@
-/* $Id: zsets.c,v 1.58 2004-08-30 12:32:24 heikki Exp $
+/* $Id: zsets.c,v 1.59 2004-08-31 10:43:35 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -403,7 +403,7 @@ ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
             while (num_i < num && positions[num_i] < position)
                 num_i++;
             rfd = rset_open (rset, RSETF_READ);
-            while (num_i < num && rset_read (rset, rfd, &key))
+            while (num_i < num && rset_read (rfd, &key))
             {
 #if IT_KEY_NEW
                 zint this_sys = key.mem[0];
@@ -433,7 +433,7 @@ ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
                     }
                 }
             }
-            rset_close (rset, rfd);
+            rset_close (rfd);
         }
     }
     return sr;
@@ -690,7 +690,7 @@ void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
         }
     }
     rfd = rset_open (rset, RSETF_READ);
-    while (rset_read (rset, rfd, &key))
+    while (rset_read (rfd, &key))
     {
 #if IT_KEY_NEW
         zint this_sys = key.mem[0];
@@ -705,7 +705,7 @@ void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
                                  sort_criteria, num_criteria, psysno);
         }
     }
-    rset_close (rset, rfd);
+    rset_close (rfd);
    
 #if 0
     for (i = 0; i < rset->no_rset_terms; i++)
@@ -760,7 +760,7 @@ void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
     }
     rc = rank_class->control;
 
-    if (rset_read (rset, rfd, &key))
+    if (rset_read (rfd, &key))
     {
 #if IT_KEY_NEW
         zint psysno = key.mem[0];
@@ -796,7 +796,7 @@ void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
             
         if ( (est==-2) && (zebraSet->hits==esthits))
         { /* time to estimate the hits */
-            rset_pos(rset,rfd,&cur,&tot); 
+            rset_pos(rfd,&cur,&tot); 
             if (tot>0) {
                 ratio=cur/tot;
                 est=(zint)(0.5+zebraSet->hits/ratio);
@@ -816,13 +816,13 @@ void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
             }
         }
         }
-        while (rset_read (rset, rfd, &key) && (est<0) );
+        while (rset_read (rfd, &key) && (est<0) );
            
         score = (*rc->calc) (handle, psysno);
         resultSetInsertRank (zh, sort_info, psysno, score, 'A');
         (*rc->end) (zh->reg, handle);
     }
-    rset_close (rset, rfd);
+    rset_close (rfd);
 /*
     for (i = 0; i < rset->no_rset_terms; i++)
     {
diff --git a/rset/rsbetween.c b/rset/rsbetween.c
index 475b208..8fd4338 100644
--- a/rset/rsbetween.c
+++ b/rset/rsbetween.c
@@ -1,4 +1,4 @@
-/* $Id: rsbetween.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsbetween.c,v 1.23 2004-08-31 10:43:36 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
    Index Data Aps
 
@@ -44,7 +44,7 @@ static RSFD r_open_between (RSET ct, int flag);
 static void r_close_between (RSFD rfd);
 static void r_delete_between (RSET ct);
 static void r_rewind_between (RSFD rfd);
-static int r_forward_between(RSET ct, RSFD rfd, void *buf, 
+static int r_forward_between(RSFD rfd, void *buf, 
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf);
 static int r_read_between (RSFD rfd, void *buf);
@@ -54,9 +54,9 @@ static void r_pos_between (RSFD rfd, double *current, double *total);
 static const struct rset_control control = 
 {
     "between",
+    r_delete_between,
     r_open_between,
     r_close_between,
-    r_delete_between,
     r_rewind_between,
     r_forward_between, /* rset_default_forward, */
     r_pos_between,
@@ -75,8 +75,6 @@ struct rset_between_info {
     RSET rset_attr;
     int (*cmp)(const void *p1, const void *p2);
     char *(*printer)(const void *p1, char *buf);
-    struct rset_between_rfd *rfd_list;
-    struct rset_between_rfd *free_list;
 };
 
 struct rset_between_rfd {
@@ -128,8 +126,6 @@ RSET rsbetween_create( NMEM nmem, int key_size,
     info->rset_attr = rset_attr;
     info->cmp = cmp;
     info->printer = printer;
-    info->rfd_list = NULL;
-    info->free_list = NULL;
     
     rnew->priv=info;
     return rnew;
@@ -140,7 +136,6 @@ static void r_delete_between (RSET ct)
 {
     struct rset_between_info *info = (struct rset_between_info *) ct->priv;
 
-    assert (info->rfd_list == NULL);
     rset_delete (info->rset_l);
     rset_delete (info->rset_m);
     rset_delete (info->rset_r);
@@ -152,86 +147,74 @@ static void r_delete_between (RSET ct)
 static RSFD r_open_between (RSET ct, int flag)
 {
     struct rset_between_info *info = (struct rset_between_info *) ct->priv;
-    struct rset_between_rfd *rfd;
+    RSFD rfd;
+    struct rset_between_rfd *p;
 
     if (flag & RSETF_WRITE)
     {
         logf (LOG_FATAL, "between set type is read-only");
         return NULL;
     }
-    rfd=info->free_list;
-    if (rfd)  
-        info->free_list=rfd->next;
+    rfd=rfd_create_base(ct);
+    if (rfd->priv)  
+        p=(struct rset_between_rfd *)rfd->priv;
     else {
-        rfd = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*rfd)));
-        rfd->buf_l = nmem_malloc(ct->nmem, (info->key_size));
-        rfd->buf_m = nmem_malloc(ct->nmem, (info->key_size));
-        rfd->buf_r = nmem_malloc(ct->nmem, (info->key_size));
-        rfd->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
+        p = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*p)));
+        rfd->priv=p;
+        p->buf_l = nmem_malloc(ct->nmem, (info->key_size));
+        p->buf_m = nmem_malloc(ct->nmem, (info->key_size));
+        p->buf_r = nmem_malloc(ct->nmem, (info->key_size));
+        p->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
     }
-    rfd->next = info->rfd_list;
-    info->rfd_list = rfd;
-    rfd->info = info;
 
-    rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
-    rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
-    rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
+    p->rfd_l = rset_open (info->rset_l, RSETF_READ);
+    p->rfd_m = rset_open (info->rset_m, RSETF_READ);
+    p->rfd_r = rset_open (info->rset_r, RSETF_READ);
     
-    rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
-    rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m);
-    rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
+    p->more_l = rset_read (p->rfd_l, p->buf_l);
+    p->more_m = rset_read (p->rfd_m, p->buf_m);
+    p->more_r = rset_read (p->rfd_r, p->buf_r);
     if (info->rset_attr)
     {
-        rfd->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
-        rfd->more_attr = rset_read (info->rset_attr, rfd->rfd_attr,
-                                    rfd->buf_attr);
+        p->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
+        p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
     }
-    rfd->level=0;
-    rfd->hits=0;
+    p->level=0;
+    p->hits=0;
     return rfd;
 }
 
 static void r_close_between (RSFD rfd)
 {
-    struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
-    struct rset_between_rfd **rfdp;
-    
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-            struct rset_between_rfd *rfd_tmp=*rfdp;
-            rset_close (info->rset_l, (*rfdp)->rfd_l);
-            rset_close (info->rset_m, (*rfdp)->rfd_m);
-            rset_close (info->rset_r, (*rfdp)->rfd_r);
-            if (info->rset_attr)
-                rset_close (info->rset_attr, (*rfdp)->rfd_attr);
-            *rfdp = (*rfdp)->next;
-            rfd_tmp->next=info->free_list;
-            info->free_list=rfd_tmp;
-            return;
-        }
-    logf (LOG_FATAL, "r_close_between but no rfd match!");
-    assert (0);
+    struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+    struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
+
+    rset_close (p->rfd_l);
+    rset_close (p->rfd_m);
+    rset_close (p->rfd_r);
+    if (info->rset_attr)
+        rset_close (p->rfd_attr);
+    rfd_delete_base(rfd);
 }
 
 static void r_rewind_between (RSFD rfd)
 {
-    struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
-    struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
+    struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+    struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
 
 #if RSBETWEEN_DEBUG
     logf (LOG_DEBUG, "rsbetween_rewind");
 #endif
-    rset_rewind (info->rset_l, p->rfd_l);
-    rset_rewind (info->rset_m, p->rfd_m);
-    rset_rewind (info->rset_r, p->rfd_r);
-    p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
-    p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
-    p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+    rset_rewind (p->rfd_l);
+    rset_rewind (p->rfd_m);
+    rset_rewind (p->rfd_r);
+    p->more_l = rset_read (p->rfd_l, p->buf_l);
+    p->more_m = rset_read (p->rfd_m, p->buf_m);
+    p->more_r = rset_read (p->rfd_r, p->buf_r);
     if (info->rset_attr)
     {
-        rset_rewind (info->rset_attr, p->rfd_attr);
-        p->more_attr = rset_read (info->rset_attr, p->rfd_attr, p->buf_attr);
+        rset_rewind (p->rfd_attr);
+        p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
     }
     p->level=0;
     p->hits=0;
@@ -239,12 +222,12 @@ static void r_rewind_between (RSFD rfd)
 
 
 
-static int r_forward_between(RSET ct, RSFD rfd, void *buf,
+static int r_forward_between(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf)
 {
-    struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
-    struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
+    struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+    struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
     int rc;
 #if RSBETWEEN_DEBUG
     log2( p, "fwd: before forward", 0,0);
@@ -252,7 +235,7 @@ static int r_forward_between(RSET ct, RSFD rfd, void *buf,
     /* It is enough to forward the m pointer here, the read will */
     /* naturally forward the l, m, and attr pointers */
     if (p->more_m)
-        p->more_m=rset_forward(info->rset_m,p->rfd_m, p->buf_m,
+        p->more_m=rset_forward(p->rfd_m, p->buf_m,
                         info->cmp,untilbuf);
 #if RSBETWEEN_DEBUG
     log2( p, "fwd: after forward M", 0,0);
@@ -269,8 +252,8 @@ static int r_forward_between(RSET ct, RSFD rfd, void *buf,
 
 static int r_read_between (RSFD rfd, void *buf)
 {
-    struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
-    struct rset_between_info *info = p->info;
+    struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+    struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
     int cmp_l=0;
     int cmp_r=0;
     int attr_match = 0;
@@ -318,15 +301,13 @@ static int r_read_between (RSFD rfd, void *buf)
                         else if (cmp_attr > 0)
                             break;
                         else if (cmp_attr==-1) 
-                            p->more_attr = rset_read (info->rset_attr, 
-                                                  p->rfd_attr, p->buf_attr);
+                            p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
                             /* if we had a forward that went all the way to
                              * the seqno, we could use that. But fwd only goes
                              * to the sysno */
                         else if (cmp_attr==-2) 
                         {
-                            p->more_attr = rset_forward(
-                                      info->rset_attr, p->rfd_attr,
+                            p->more_attr = rset_forward( p->rfd_attr,
                                       p->buf_attr, info->cmp, p->buf_l);
 #if RSBETWEEN_DEBUG
                             logf(LOG_DEBUG, "btw: after frowarding attr m=%d",p->more_attr);
@@ -341,7 +322,7 @@ static int r_read_between (RSFD rfd, void *buf)
             {
                 if (p->more_l) 
                 {
-                    p->more_l=rset_forward( info->rset_l, p->rfd_l,
+                    p->more_l=rset_forward(p->rfd_l,
                                       p->buf_l, info->cmp, p->buf_m);
                     if (p->more_l)
                         cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
@@ -353,10 +334,10 @@ static int r_read_between (RSFD rfd, void *buf)
                 }
             } else
             {
-                p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+                p->more_l = rset_read (p->rfd_l, p->buf_l);
             }
 #else
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+            p->more_l = rset_read (p->rfd_l, p->buf_l);
 #endif
             if (p->more_l)
             {
@@ -391,17 +372,17 @@ static int r_read_between (RSFD rfd, void *buf)
 #if NEWCODE                
                 if (cmp_r==-2)
                 {
-                    p->more_r=rset_forward( info->rset_r, p->rfd_r,
+                    p->more_r=rset_forward(p->rfd_r,
                                       p->buf_r, info->cmp, p->buf_m);
                 } else
                 {
-                    p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+                    p->more_r = rset_read (p->rfd_r, p->buf_r);
                 }
                 if (p->more_r)
                     cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 
 #else
-                p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+                p->more_r = rset_read (p->rfd_r, p->buf_r);
                 cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 #endif
             }
@@ -421,7 +402,7 @@ static int r_read_between (RSFD rfd, void *buf)
 #if RSBETWEEN_DEBUG
             log2( p, "Returning a hit (and forwarding m)", cmp_l, cmp_r);
 #endif
-            p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+            p->more_m = rset_read (p->rfd_m, p->buf_m);
             if (cmp_l == 2)
                 p->level = 0;
             p->hits++;
@@ -438,16 +419,16 @@ static int r_read_between (RSFD rfd, void *buf)
         if (cmp_l == 2)
         {
             p->level = 0;
-            p->more_m=rset_forward( info->rset_m, p->rfd_m,
+            p->more_m=rset_forward(p->rfd_m,
                               p->buf_m, info->cmp, p->buf_l);
         } else
         {
-            p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+            p->more_m = rset_read (p->rfd_m, p->buf_m);
         }
 #else
         if (cmp_l == 2)
             p->level = 0;
-        p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+        p->more_m = rset_read (p->rfd_m, p->buf_m);
 #endif
 #if RSBETWEEN_DEBUG
         log2( p, "End of M loop", cmp_l, cmp_r);
@@ -472,16 +453,15 @@ static int r_write_between (RSFD rfd, const void *buf)
 
 static void r_pos_between (RSFD rfd, double *current, double *total)
 {
-    struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
-    struct rset_between_info *info = p->info;
+    struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
     double lcur,ltot;
     double mcur,mtot;
     double rcur,rtot;
     double r;
     ltot=-1; rtot=-1;
-    rset_pos(info->rset_l, p->rfd_l,  &lcur, &ltot);
-    rset_pos(info->rset_m, p->rfd_m,  &mcur, &mtot);
-    rset_pos(info->rset_r, p->rfd_r,  &rcur, &rtot);
+    rset_pos(p->rfd_l,  &lcur, &ltot);
+    rset_pos(p->rfd_m,  &mcur, &mtot);
+    rset_pos(p->rfd_r,  &rcur, &rtot);
     if ( (ltot<0) && (mtot<0) && (rtot<0) ) { /*no position */
         *current=mcur;  /* return same as you got */
         *total=mtot;    /* probably -1 for not available */
diff --git a/rset/rsbool.c b/rset/rsbool.c
index b07a50e..a427538 100644
--- a/rset/rsbool.c
+++ b/rset/rsbool.c
@@ -1,4 +1,4 @@
-/* $Id: rsbool.c,v 1.44 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsbool.c,v 1.45 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -37,7 +37,7 @@ static RSFD r_open (RSET ct, int flag);
 static void r_close (RSFD rfd);
 static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf);
 static void r_pos (RSFD rfd, double *current, double *total); 
@@ -49,9 +49,9 @@ static int r_write (RSFD rfd, const void *buf);
 static const struct rset_control control_and = 
 {
     "and",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward, 
     r_pos,    
@@ -62,9 +62,9 @@ static const struct rset_control control_and =
 static const struct rset_control control_or = 
 {
     "or",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward, 
     r_pos,
@@ -75,9 +75,9 @@ static const struct rset_control control_or =
 static const struct rset_control control_not = 
 {
     "not",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward, 
     r_pos,
@@ -96,8 +96,6 @@ struct rset_bool_info {
     RSET rset_r;
     int (*cmp)(const void *p1, const void *p2);
     void (*log_item)(int logmask, const void *p, const char *txt);
-    struct rset_bool_rfd *rfd_list;  /* RSFDs in use */
-    struct rset_bool_rfd *free_list; /* RSFDs that are freed (for reuse) */
 };
 
 struct rset_bool_rfd {
@@ -127,8 +125,6 @@ static RSET rsbool_create_base( const struct rset_control *ctrl,
     info->rset_r = rset_r;
     info->cmp = cmp;
     info->log_item = log_item;
-    info->rfd_list = NULL;
-    info->free_list = NULL;
     
     rnew->priv=info;
     return rnew;
@@ -165,133 +161,84 @@ RSET rsbool_create_not( NMEM nmem, int key_size,
 static void r_delete (RSET ct)
 {
     struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
-
-    assert (info->rfd_list == NULL);
     rset_delete (info->rset_l);
     rset_delete (info->rset_r);
 }
 
-#if 0
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_bool_parms *bool_parms = (rset_bool_parms *) parms;
-    struct rset_bool_info *info;
-
-    info = (struct rset_bool_info *) xmalloc (sizeof(*info));
-    info->key_size = bool_parms->key_size;
-    info->rset_l = bool_parms->rset_l;
-    info->rset_r = bool_parms->rset_r;
-    info->cmp = bool_parms->cmp;
-    info->log_item = bool_parms->log_item;
-    info->rfd_list = NULL;
-    
-    return info;
-}
-#endif
 
 static RSFD r_open (RSET ct, int flag)
 {
     struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
-    struct rset_bool_rfd *rfd;
+    RSFD rfd;
+    struct rset_bool_rfd *p;
+   
 
     if (flag & RSETF_WRITE)
     {
         logf (LOG_FATAL, "bool set type is read-only");
         return NULL;
     }
-    rfd = info->free_list;
-    if (rfd)
-	info->free_list = rfd->next;
+    rfd = rfd_create_base(ct);
+    if (rfd->priv)
+        p=(struct rset_bool_rfd *)rfd->priv;
     else {
-        rfd = (struct rset_bool_rfd *) nmem_malloc(ct->nmem, sizeof(*rfd));
-        rfd->buf_l = nmem_malloc(ct->nmem, info->key_size);
-        rfd->buf_r = nmem_malloc(ct->nmem, info->key_size);
+        p=nmem_malloc(ct->nmem,sizeof(*p));
+        rfd->priv=p;
+        p->buf_l = nmem_malloc(ct->nmem, info->key_size);
+        p->buf_r = nmem_malloc(ct->nmem, info->key_size);
     }
 
     logf(LOG_DEBUG,"rsbool (%s) open [%p]", ct->control->desc, rfd);
-    rfd->next = info->rfd_list;
-    info->rfd_list = rfd;
-    rfd->info = info;
-    rfd->hits=0;
-
-    rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
-    rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
-    rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
-    rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
-    rfd->tail = 0;
+    p->hits=0;
+
+    p->rfd_l = rset_open (info->rset_l, RSETF_READ);
+    p->rfd_r = rset_open (info->rset_r, RSETF_READ);
+    p->more_l = rset_read (p->rfd_l, p->buf_l);
+    p->more_r = rset_read (p->rfd_r, p->buf_r);
+    p->tail = 0;
     return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
-    struct rset_bool_rfd **rfdp;
-    
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-	    struct rset_bool_rfd *rfd_tmp = *rfdp;
-
-            rset_close (info->rset_l, (*rfdp)->rfd_l);
-            rset_close (info->rset_r, (*rfdp)->rfd_r);
-            *rfdp = (*rfdp)->next;
-
-	    rfd_tmp->next = info->free_list;
-	    info->free_list = rfd_tmp;
+ /* struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv); */
+    struct rset_bool_rfd *prfd=(struct rset_bool_rfd *)rfd->priv;
 
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    rset_close (prfd->rfd_l);
+    rset_close (prfd->rfd_r);
+    rfd_delete_base(rfd);
 }
 
 
 static void r_rewind (RSFD rfd)
 {
-    struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
+ /* struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv); */
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
 
     logf (LOG_DEBUG, "rsbool_rewind");
-    rset_rewind (info->rset_l, p->rfd_l);
-    rset_rewind (info->rset_r, p->rfd_r);
-    p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
-    p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+    rset_rewind (p->rfd_l);
+    rset_rewind (p->rfd_r);
+    p->more_l = rset_read (p->rfd_l, p->buf_l);
+    p->more_r = rset_read (p->rfd_r, p->buf_r);
     p->hits=0;
 }
 
-static int r_forward (RSET ct, RSFD rfd, void *buf,
+static int r_forward (RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf)
 {
-    struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
+    struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
     int rc;
 
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rsbool_forward (L) [%p] '%s' (ct=%p rfd=%p m=%d,%d)",
-                      rfd, ct->control->desc, ct, rfd, p->more_l, p->more_r);
-#endif
     if ( p->more_l && ((cmpfunc)(untilbuf,p->buf_l)==2) )
-        p->more_l = rset_forward(info->rset_l, p->rfd_l, p->buf_l,
+        p->more_l = rset_forward(p->rfd_l, p->buf_l,
                         info->cmp, untilbuf);
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rsbool_forward (R) [%p] '%s' (ct=%p rfd=%p m=%d,%d)",
-                      rfd, ct->control->desc, ct, rfd, p->more_l, p->more_r);
-#endif
     if ( p->more_r && ((cmpfunc)(untilbuf,p->buf_r)==2))
-        p->more_r = rset_forward(info->rset_r, p->rfd_r, p->buf_r,
+        p->more_r = rset_forward(p->rfd_r, p->buf_r,
                         info->cmp, untilbuf);
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rsbool_forward [%p] calling read, m=%d,%d t=%d", 
-                       rfd, p->more_l, p->more_r, p->tail);
-#endif
-    
     p->tail=0; 
-    rc = rset_read(ct,rfd,buf); 
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rsbool_forward returning [%p] %d m=%d,%d", 
-                       rfd, rc, p->more_l, p->more_r);
-#endif
+    rc = rset_read(rfd,buf); 
     return rc;
 }
 
@@ -313,8 +260,8 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
 
 static int r_read_and (RSFD rfd, void *buf)
 {
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
-    struct rset_bool_info *info = p->info;
+    struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
 
     while (p->more_l || p->more_r)
     {
@@ -335,13 +282,13 @@ static int r_read_and (RSFD rfd, void *buf)
         if (!cmp)
         {
             memcpy (buf, p->buf_l, info->key_size);
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+            p->more_l = rset_read (p->rfd_l, p->buf_l);
             p->tail = 1;
         }
         else if (cmp == 1)
         {
             memcpy (buf, p->buf_r, info->key_size);
-            p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+            p->more_r = rset_read (p->rfd_r, p->buf_r);
             p->tail = 1;
 #if RSET_DEBUG
             logf (LOG_DEBUG, "r_read_and [%p] returning R m=%d/%d c=%d",
@@ -355,7 +302,7 @@ static int r_read_and (RSFD rfd, void *buf)
         else if (cmp == -1)
         {
             memcpy (buf, p->buf_l, info->key_size);
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+            p->more_l = rset_read (p->rfd_l, p->buf_l);
             p->tail = 1;
 #if RSET_DEBUG
             logf (LOG_DEBUG, "r_read_and [%p] returning L m=%d/%d c=%d",
@@ -371,7 +318,7 @@ static int r_read_and (RSFD rfd, void *buf)
 #if OLDCODE
             memcpy (buf, p->buf_r, info->key_size);
             
-            p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+            p->more_r = rset_read (p->rfd_r, p->buf_r);
             if (p->tail)
             {
                 if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
@@ -389,7 +336,7 @@ static int r_read_and (RSFD rfd, void *buf)
             if (p->tail)
             {
                 memcpy (buf, p->buf_r, info->key_size);
-                p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+                p->more_r = rset_read (p->rfd_r, p->buf_r);
                 if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
                     p->tail = 0;
 #if RSET_DEBUG
@@ -407,7 +354,7 @@ static int r_read_and (RSFD rfd, void *buf)
                         rfd, p->more_l, p->more_r, cmp);
 #endif
                 if (p->more_r && p->more_l)
-                    p->more_r = rset_forward( info->rset_r, p->rfd_r, 
+                    p->more_r = rset_forward( p->rfd_r, 
                                     p->buf_r, (info->cmp), p->buf_l);
                 else 
                     return 0; /* no point in reading further */
@@ -418,7 +365,7 @@ static int r_read_and (RSFD rfd, void *buf)
         {
 #if OLDCODE
              memcpy (buf, p->buf_l, info->key_size);
-             p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+             p->more_l = rset_read (p->rfd_l, p->buf_l);
              if (p->tail)
              {
                  if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
@@ -435,7 +382,7 @@ static int r_read_and (RSFD rfd, void *buf)
             if (p->tail)
             {
                 memcpy (buf, p->buf_l, info->key_size);
-                p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+                p->more_l = rset_read (p->rfd_l, p->buf_l);
                 if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
                     p->tail = 0;
 #if RSET_DEBUG
@@ -453,8 +400,7 @@ static int r_read_and (RSFD rfd, void *buf)
                         rfd, p->more_l, p->more_r, cmp);
 #endif
                 if (p->more_r && p->more_l)
-                    p->more_l = rset_forward( 
-                                    info->rset_l, p->rfd_l, 
+                    p->more_l = rset_forward(p->rfd_l, 
                                     p->buf_l, (info->cmp), p->buf_r);
                 else 
                     return 0; /* no point in reading further */
@@ -470,8 +416,8 @@ static int r_read_and (RSFD rfd, void *buf)
 
 static int r_read_or (RSFD rfd, void *buf)
 {
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
-    struct rset_bool_info *info = p->info;
+    struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
 
     while (p->more_l || p->more_r)
     {
@@ -486,8 +432,8 @@ static int r_read_or (RSFD rfd, void *buf)
         if (!cmp)
         {
             memcpy (buf, p->buf_l, info->key_size);
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
-            p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+            p->more_l = rset_read (p->rfd_l, p->buf_l);
+            p->more_r = rset_read (p->rfd_r, p->buf_r);
 #if RSET_DEBUG
             logf (LOG_DEBUG, "r_read_or returning A m=%d/%d c=%d",
                     p->more_l, p->more_r, cmp);
@@ -499,7 +445,7 @@ static int r_read_or (RSFD rfd, void *buf)
         else if (cmp > 0)
         {
             memcpy (buf, p->buf_r, info->key_size);
-            p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+            p->more_r = rset_read (p->rfd_r, p->buf_r);
 #if RSET_DEBUG
             logf (LOG_DEBUG, "r_read_or returning B m=%d/%d c=%d",
                     p->more_l, p->more_r, cmp);
@@ -511,7 +457,7 @@ static int r_read_or (RSFD rfd, void *buf)
         else
         {
             memcpy (buf, p->buf_l, info->key_size);
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+            p->more_l = rset_read ( p->rfd_l, p->buf_l);
 #if RSET_DEBUG
             logf (LOG_DEBUG, "r_read_or returning C m=%d/%d c=%d",
                     p->more_l, p->more_r, cmp);
@@ -526,8 +472,8 @@ static int r_read_or (RSFD rfd, void *buf)
 
 static int r_read_not (RSFD rfd, void *buf)
 {
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
-    struct rset_bool_info *info = p->info;
+    struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
 
     while (p->more_l || p->more_r)
     {
@@ -542,14 +488,13 @@ static int r_read_not (RSFD rfd, void *buf)
         if (cmp < -1)
         {
             memcpy (buf, p->buf_l, info->key_size);
-            p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+            p->more_l = rset_read (p->rfd_l, p->buf_l);
             p->hits++;
             return 1;
         }
         else if (cmp > 1)
         {
-                p->more_r = rset_forward( 
-                    info->rset_r, p->rfd_r, 
+                p->more_r = rset_forward( p->rfd_r, 
                     p->buf_r, (info->cmp), p->buf_l);
         }
         else
@@ -557,14 +502,14 @@ static int r_read_not (RSFD rfd, void *buf)
             memcpy (buf, p->buf_l, info->key_size);
             do
             { 
-                p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+                p->more_l = rset_read (p->rfd_l, p->buf_l);
                 if (!p->more_l)
                     break;
                 cmp = (*info->cmp)(p->buf_l, buf);
             } while (cmp >= -1 && cmp <= 1);
             do
             {
-                p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+                p->more_r = rset_read (p->rfd_r, p->buf_r);
                 if (!p->more_r)
                     break;
                 cmp = (*info->cmp)(p->buf_r, buf);
@@ -583,14 +528,13 @@ static int r_write (RSFD rfd, const void *buf)
 
 static void r_pos (RSFD rfd, double *current, double *total)
 {
-    struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
-    struct rset_bool_info *info = p->info;
+    struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
     double lcur,ltot;
     double rcur,rtot;
     double r;
     ltot=-1; rtot=-1;
-    rset_pos(info->rset_l, p->rfd_l,  &lcur, &ltot);
-    rset_pos(info->rset_r, p->rfd_r,  &rcur, &rtot);
+    rset_pos(p->rfd_l,  &lcur, &ltot);
+    rset_pos(p->rfd_r,  &rcur, &rtot);
     if ( (rtot<0) && (ltot<0)) { /*no position */
         *current=rcur;  /* return same as you got */
         *total=rtot;    /* probably -1 for not available */
diff --git a/rset/rset.c b/rset/rset.c
index e24ef47..51df906 100644
--- a/rset/rset.c
+++ b/rset/rset.c
@@ -1,4 +1,4 @@
-/* $Id: rset.c,v 1.28 2004-08-24 15:00:16 heikki Exp $
+/* $Id: rset.c,v 1.29 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -29,18 +29,55 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include <yaz/nmem.h>
 #include <rset.h>
 
+
+/* creates an rfd. Either allocates a new one, in which case the priv */
+/* pointer is null, and will have to be filled in, or picks up one */
+/* from the freelist, in which case the priv is already allocated, */
+/* and presumably everything that hangs from it as well */
+
+RSFD rfd_create_base(RSET rs)
+{
+    RSFD rnew=rs->free_list;
+    if (rnew) {
+        rs->free_list=rnew->next;
+        assert(rnew->rset==rs);
+  /*    logf(LOG_DEBUG,"rfd-create_base (fl): rfd=%p rs=%p fl=%p priv=%p", 
+                       rnew, rs, rs->free_list, rnew->priv); */
+    } else {
+        rnew=nmem_malloc(rs->nmem, sizeof(*rnew));
+        rnew->priv=NULL;
+        rnew->rset=rs;
+  /*    logf(LOG_DEBUG,"rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p", 
+                       rnew, rs, rs->free_list, rnew->priv); */
+    }
+    rnew->next=NULL; /* not part of any (free?) list */
+    return rnew;
+}
+
+/* puts an rfd into the freelist of the rset. Only when the rset gets */
+/* deleted, will all the nmem disappear */
+void rfd_delete_base(RSFD rfd) 
+{
+    RSET rs=rfd->rset;
+ /* logf(LOG_DEBUG,"rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p",
+            rfd, rs, rfd->priv, rs->free_list); */
+    assert(NULL == rfd->next); 
+    rfd->next=rs->free_list;
+    rs->free_list=rfd;
+}
+
 RSET rset_create_base(const struct rset_control *sel, NMEM nmem)
         /* FIXME - Add keysize and cmp function */
         /* FIXME - Add a general key-func block for cmp, dump, etc */
 {
     RSET rnew;
     NMEM M;
-    logf (LOG_DEBUG, "rs_create(%s)", sel->desc);
     if (nmem) 
         M=nmem;
     else
         M=nmem_create();
     rnew = (RSET) nmem_malloc(M,sizeof(*rnew));
+ /* logf (LOG_DEBUG, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rnew, nmem); */
     rnew->nmem=M;
     if (nmem)
         rnew->my_nmem=0;
@@ -49,6 +86,7 @@ RSET rset_create_base(const struct rset_control *sel, NMEM nmem)
     rnew->control = sel;
     rnew->count = 1;
     rnew->priv = 0;
+    rnew->free_list=NULL;
     
     return rnew;
 }
@@ -56,6 +94,8 @@ RSET rset_create_base(const struct rset_control *sel, NMEM nmem)
 void rset_delete (RSET rs)
 {
     (rs->count)--;
+/*  logf(LOG_DEBUG,"rs_delete(%s), rs=%p, count=%d",
+            rs->control->desc, rs, rs->count); */
     if (!rs->count)
     {
         (*rs->control->f_delete)(rs);
@@ -70,6 +110,7 @@ RSET rset_dup (RSET rs)
     return rs;
 }
 
+#if 0
 void rset_default_pos (RSFD rfd, double *current, double *total)
 { /* This should never really be needed, but it is still used in */
   /* those rsets that we don't really plan to use, like isam-s */
@@ -79,20 +120,21 @@ void rset_default_pos (RSFD rfd, double *current, double *total)
     *current=-1; /* signal that pos is not implemented */
     *total=-1;
 } /* rset_default_pos */
+#endif
 
-int rset_default_forward(RSET ct, RSFD rfd, void *buf, 
+int rset_default_forward(RSFD rfd, void *buf, 
                            int (*cmpfunc)(const void *p1, const void *p2), 
                            const void *untilbuf)
 {
     int more=1;
     int cmp=2;
     logf (LOG_DEBUG, "rset_default_forward starting '%s' (ct=%p rfd=%p)",
-                    ct->control->desc, ct,rfd);
+                    rfd->rset->control->desc, rfd->rset, rfd);
     /* key_logdump(LOG_DEBUG, untilbuf); */
     while ( (cmp==2) && (more))
     {
         logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
-        more=rset_read(ct, rfd, buf);
+        more=rset_read(rfd, buf);
         if (more)
             cmp=(*cmpfunc)(untilbuf,buf);
 /*        if (more)
diff --git a/rset/rsisamb.c b/rset/rsisamb.c
index c737607..e39ac6b 100644
--- a/rset/rsisamb.c
+++ b/rset/rsisamb.c
@@ -1,4 +1,4 @@
-/* $Id: rsisamb.c,v 1.18 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsisamb.c,v 1.19 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -35,7 +35,7 @@ static RSFD r_open (RSET ct, int flag);
 static void r_close (RSFD rfd);
 static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf);
 static void r_pos (RSFD rfd, double *current, double *total);
@@ -45,9 +45,9 @@ static int r_write (RSFD rfd, const void *buf);
 static const struct rset_control control = 
 {
     "isamb",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward, /* rset_default_forward, */
     r_pos,
@@ -59,8 +59,6 @@ const struct rset_control *rset_kind_isamb = &control;
 
 struct rset_pp_info {
     ISAMB_PP pt;
-    struct rset_pp_info *next;
-    struct rset_isamb_info *info;
     void *buf;
 };
 
@@ -69,8 +67,6 @@ struct rset_isamb_info {
     ISAMB_P pos;
     int key_size;
     int (*cmp)(const void *p1, const void *p2);
-    struct rset_pp_info *ispt_list;
-    struct rset_pp_info *free_list;
 };
 
 RSET rsisamb_create( NMEM nmem, int key_size, 
@@ -84,78 +80,43 @@ RSET rsisamb_create( NMEM nmem, int key_size,
     info->cmp = cmp;
     info->is=is;
     info->pos=pos;
-    info->ispt_list = NULL;
-    info->free_list = NULL;
     rnew->priv=info;
     return rnew;
 }
 
 static void r_delete (RSET ct)
 {
-    struct rset_isamb_info *info = (struct rset_isamb_info *) ct->priv;
-
     logf (LOG_DEBUG, "rsisamb_delete");
-    assert (info->ispt_list == NULL);
-}
-
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_isamb_parms *pt = (rset_isamb_parms *) parms;
-    struct rset_isamb_info *info;
-
-    info = (struct rset_isamb_info *) xmalloc (sizeof(*info));
-    info->is = pt->is;
-    info->pos = pt->pos;
-    info->key_size = pt->key_size;
-    info->cmp = pt->cmp;
-    info->ispt_list = NULL;
-    return info;
 }
-#endif
 
 RSFD r_open (RSET ct, int flag)
 {
     struct rset_isamb_info *info = (struct rset_isamb_info *) ct->priv;
+    RSFD rfd;
     struct rset_pp_info *ptinfo;
 
-    logf (LOG_DEBUG, "risamb_open");
     if (flag & RSETF_WRITE)
     {
         logf (LOG_FATAL, "ISAMB set type is read-only");
         return NULL;
     }
-    ptinfo = info->free_list;
-    if (ptinfo)
-        info->free_list=ptinfo->next;
+    rfd=rfd_create_base(ct);
+    if (rfd->priv)
+        ptinfo=(struct rset_pp_info *) (rfd->priv);
     else {
         ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
         ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
+        rfd->priv=ptinfo;
     }
-    ptinfo->next = info->ispt_list;
-    info->ispt_list = ptinfo;
     ptinfo->pt = isamb_pp_open (info->is, info->pos);
-    ptinfo->info = info;
-    return ptinfo;
+    return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_isamb_info *info = ((struct rset_pp_info*) rfd)->info;
-    struct rset_pp_info **ptinfop;
-
-    for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
-        if (*ptinfop == rfd)
-        {
-            struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
-            isamb_pp_close ((*ptinfop)->pt);
-            *ptinfop = (*ptinfop)->next;
-            tmp->next=info->free_list;
-            info->free_list=tmp;
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+    isamb_pp_close (ptinfo->pt);
+    rfd_delete_base(rfd);
 }
 
 
@@ -165,29 +126,17 @@ static void r_rewind (RSFD rfd)
     abort ();
 }
 
-static int r_forward(RSET ct, RSFD rfd, void *buf, 
+static int r_forward(RSFD rfd, void *buf, 
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf)
 {
-    int i; 
-    struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rset_rsisamb_forward starting '%s' (ct=%p rfd=%p)",
-                      ct->control->desc, ct,rfd);
-    key_logdump(LOG_DEBUG, untilbuf);
-    key_logdump(LOG_DEBUG, buf);
-#endif
-
-    i=isamb_pp_forward(pinfo->pt, buf, untilbuf);
-#if RSET_DEBUG
-    logf (LOG_DEBUG, "rset_rsisamb_forward returning %d",i);
-#endif
-    return i;
+    struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
+    return isamb_pp_forward(pinfo->pt, buf, untilbuf);
 }
 
 static void r_pos (RSFD rfd, double *current, double *total)
 {
-    struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
+    struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
     assert(rfd);
     isamb_pp_pos(pinfo->pt, current, total);
 #if RSET_DEBUG
@@ -198,11 +147,9 @@ static void r_pos (RSFD rfd, double *current, double *total)
 
 static int r_read (RSFD rfd, void *buf)
 {
-    struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
-    int r;
+    struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
 
-    r = isamb_pp_read(pinfo->pt, buf);
-    return r;
+    return isamb_pp_read(pinfo->pt, buf);
 }
 
 static int r_write (RSFD rfd, const void *buf)
diff --git a/rset/rsisamc.c b/rset/rsisamc.c
index 273d86e..126066e 100644
--- a/rset/rsisamc.c
+++ b/rset/rsisamc.c
@@ -1,4 +1,4 @@
-/* $Id: rsisamc.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsisamc.c,v 1.23 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -35,16 +35,17 @@ static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
 static int r_read (RSFD rfd, void *buf);
 static int r_write (RSFD rfd, const void *buf);
+static void r_pos (RSFD rfd, double *current, double *total);
 
 static const struct rset_control control = 
 {
     "isamc",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     rset_default_forward,
-    rset_default_pos,
+    r_pos,
     r_read,
     r_write,
 };
@@ -92,25 +93,11 @@ static void r_delete (RSET ct)
     assert (info->ispt_list == NULL);
 }
 
-/*
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_isamc_parms *pt = (rset_isamc_parms *) parms;
-    struct rset_isamc_info *info;
-
-    info = (struct rset_isamc_info *) xmalloc (sizeof(*info));
-    info->is = pt->is;
-    info->pos = pt->pos;
-    info->key_size = pt->key_size;
-    info->cmp = pt->cmp;
-    info->ispt_list = NULL;
-    return info;
-}
-*/
 
 RSFD r_open (RSET ct, int flag)
 {
     struct rset_isamc_info *info = (struct rset_isamc_info *) ct->priv;
+    RSFD rfd;
     struct rset_pp_info *ptinfo;
 
     logf (LOG_DEBUG, "risamc_open");
@@ -119,37 +106,23 @@ RSFD r_open (RSET ct, int flag)
         logf (LOG_FATAL, "ISAMC set type is read-only");
         return NULL;
     }
-    ptinfo = info->free_list;
-    if (ptinfo)
-        info->free_list=ptinfo->next;
+    rfd = rfd_create_base(ct);
+    if (rfd->priv)
+        ptinfo=(struct rset_pp_info *)rfd->priv;
     else {
         ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
+        rfd->priv=ptinfo;
         ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
     }
-    ptinfo->next = info->ispt_list;
-    info->ispt_list = ptinfo;
-    ptinfo->pt = isc_pp_open (info->is, info->pos);
-    ptinfo->info = info;
-    return ptinfo;
+    return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_isamc_info *info = ((struct rset_pp_info*) rfd)->info;
-    struct rset_pp_info **ptinfop;
-
-    for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
-        if (*ptinfop == rfd)
-        {
-            struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
-            isc_pp_close ((*ptinfop)->pt);
-            *ptinfop = (*ptinfop)->next;
-            tmp->next=info->free_list;
-            info->free_list=tmp;
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    struct rset_pp_info *p=(struct rset_pp_info *)(rfd->priv);
+
+    isc_pp_close (p->pt);
+    rfd_delete_base(rfd);
 }
 
 
@@ -161,9 +134,9 @@ static void r_rewind (RSFD rfd)
 
 static int r_read (RSFD rfd, void *buf)
 {
-    struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
+    struct rset_pp_info *p=(struct rset_pp_info *)(rfd->priv);
     int r;
-    r = isc_pp_read(pinfo->pt, buf);
+    r = isc_pp_read(p->pt, buf);
     return r;
 }
 
@@ -172,3 +145,9 @@ static int r_write (RSFD rfd, const void *buf)
     logf (LOG_FATAL, "ISAMC set type is read-only");
     return -1;
 }
+
+static void r_pos (RSFD rfd, double *current, double *total)
+{
+    *current=-1;  /* sorry, not implemented yet */
+    *total=-1;
+}
diff --git a/rset/rsisams.c b/rset/rsisams.c
index 79ee4f4..e6031e1 100644
--- a/rset/rsisams.c
+++ b/rset/rsisams.c
@@ -1,4 +1,4 @@
-/* $Id: rsisams.c,v 1.10 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsisams.c,v 1.11 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
    Index Data Aps
 
@@ -33,16 +33,17 @@ static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
 static int r_read (RSFD rfd, void *buf);
 static int r_write (RSFD rfd, const void *buf);
+static void r_pos (RSFD rfd, double *current, double *total);
 
 static const struct rset_control control = 
 {
     "isams",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     rset_default_forward,
-    rset_default_pos,
+    r_pos,
     r_read,
     r_write,
 };
@@ -51,14 +52,11 @@ const struct rset_control *rset_kind_isams = &control;
 
 struct rset_pp_info {
     ISAMS_PP pt;
-    struct rset_pp_info *next;
-    struct rset_isams_info *info;
 };
 
 struct rset_isams_info {
     ISAMS   is;
     ISAMS_P pos;
-    struct rset_pp_info *ispt_list;
 };
 
 
@@ -73,37 +71,21 @@ RSET rsisams_create( NMEM nmem, int key_size,
     assert(cmp);
     info->is=is;
     info->pos=pos;
-    info->ispt_list = NULL;
     rnew->priv=info;
     return rnew;
 }
 
 static void r_delete (RSET ct)
 {
-    struct rset_isams_info *info = (struct rset_isams_info *) ct->priv;
-
     logf (LOG_DEBUG, "rsisams_delete");
-    assert (info->ispt_list == NULL);
-    /* xfree (info); */
+    rset_delete(ct);
 }
 
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_isams_parms *pt = (struct rset_isams_parms *) parms;
-    struct rset_isams_info *info;
-
-    info = (struct rset_isams_info *) xmalloc (sizeof(*info));
-    info->is = pt->is;
-    info->pos = pt->pos;
-    info->ispt_list = NULL;
-    return info;
-}
-#endif
 
 RSFD r_open (RSET ct, int flag)
 {
     struct rset_isams_info *info = (struct rset_isams_info *) ct->priv;
+    RSFD rfd;
     struct rset_pp_info *ptinfo;
 
     logf (LOG_DEBUG, "risams_open");
@@ -112,29 +94,23 @@ RSFD r_open (RSET ct, int flag)
         logf (LOG_FATAL, "ISAMS set type is read-only");
         return NULL;
     }
-    ptinfo = (struct rset_pp_info *) xmalloc (sizeof(*ptinfo));
-    ptinfo->next = info->ispt_list;
-    info->ispt_list = ptinfo;
-    ptinfo->pt = isams_pp_open (info->is, info->pos);
-    ptinfo->info = info;
-    return ptinfo;
+    rfd=rfd_create_base(ct);
+    if (rfd->priv)
+        ptinfo=(struct rset_pp_info *)(rfd->priv);
+    else {
+        ptinfo = (struct rset_pp_info *) nmem_malloc(ct->nmem,sizeof(*ptinfo));
+        ptinfo->pt = isams_pp_open (info->is, info->pos);
+        rfd->priv=ptinfo;
+    }
+    return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_isams_info *info = ((struct rset_pp_info*) rfd)->info;
-    struct rset_pp_info **ptinfop;
-
-    for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
-        if (*ptinfop == rfd)
-        {
-            isams_pp_close ((*ptinfop)->pt);
-            *ptinfop = (*ptinfop)->next;
-            xfree (rfd);
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+
+    isams_pp_close (ptinfo->pt);
+    rfd_delete_base(rfd);
 }
 
 static void r_rewind (RSFD rfd)
@@ -146,7 +122,8 @@ static void r_rewind (RSFD rfd)
 
 static int r_read (RSFD rfd, void *buf)
 {
-    return isams_pp_read( ((struct rset_pp_info*) rfd)->pt, buf);
+    struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+    return isams_pp_read(ptinfo->pt, buf);
 }
 
 static int r_write (RSFD rfd, const void *buf)
@@ -154,3 +131,9 @@ static int r_write (RSFD rfd, const void *buf)
     logf (LOG_FATAL, "ISAMS set type is read-only");
     return -1;
 }
+
+static void r_pos (RSFD rfd, double *current, double *total)
+{
+    *current=-1;  /* sorry, not implemented yet */
+    *total=-1;
+}
diff --git a/rset/rsm_or.c b/rset/rsm_or.c
deleted file mode 100644
index dee7955..0000000
--- a/rset/rsm_or.c
+++ /dev/null
@@ -1,341 +0,0 @@
-/* $Id: rsm_or.c,v 1.20 2004-08-20 14:44:46 heikki Exp $
-   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
-   Index Data Aps
-
-This file is part of the Zebra server.
-
-Zebra is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
-
-Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with Zebra; see the file LICENSE.zebra.  If not, write to the
-Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.
-*/
-
-
-
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <zebrautl.h>
-#include <isamc.h>
-#include <rsm_or.h>
-
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms);
-static RSFD r_open (RSET ct, int flag);
-static void r_close (RSFD rfd);
-static void r_delete (RSET ct);
-static void r_rewind (RSFD rfd);
-static int r_read (RSFD rfd, void *buf);
-static int r_write (RSFD rfd, const void *buf);
-
-static const struct rset_control control = 
-{
-    "m-or (old)",
-    r_create,
-    r_open,
-    r_close,
-    r_delete,
-    r_rewind,
-    rset_default_forward, /* FIXME */
-    rset_default_pos, /* FIXME */
-    r_read,
-    r_write,
-};
-
-const struct rset_control *rset_kind_m_or = &control;
-
-struct rset_mor_info {
-    int     key_size;
-    int     no_rec;
-    int     (*cmp)(const void *p1, const void *p2);
-    ISAMC   isc;
-    ISAMC_P *isam_positions;
-
-    int     no_isam_positions;
-    int     no_save_positions;
-    struct rset_mor_rfd *rfd_list;
-};
-
-struct trunc_info {
-    int  *ptr;
-    int  *indx;
-    char **heap;
-    int  heapnum;
-    int  (*cmp)(const void *p1, const void *p2);
-    int  keysize;
-    char *swapbuf;
-    char *tmpbuf;
-    char *buf;
-};
-
-struct rset_mor_rfd {
-    int flag;
-    int position;
-    int position_max;
-    ISAMC_PP *ispt;
-    struct rset_mor_rfd *next;
-    struct rset_mor_info *info;
-    struct trunc_info *ti;
-    char *pbuf;
-};
-
-static void heap_swap (struct trunc_info *ti, int i1, int i2)
-{
-    int swap;
-
-    swap = ti->ptr[i1];
-    ti->ptr[i1] = ti->ptr[i2];
-    ti->ptr[i2] = swap;
-}
-
-static void heap_delete (struct trunc_info *ti)
-{
-    int cur = 1, child = 2;
-
-    heap_swap (ti, 1, ti->heapnum--);
-    while (child <= ti->heapnum) {
-        if (child < ti->heapnum &&
-            (*ti->cmp)(ti->heap[ti->ptr[child]],
-                       ti->heap[ti->ptr[1+child]]) > 0)
-            child++;
-        if ((*ti->cmp)(ti->heap[ti->ptr[cur]],
-                       ti->heap[ti->ptr[child]]) > 0)
-        {
-            heap_swap (ti, cur, child);
-            cur = child;
-            child = 2*cur;
-        }
-        else
-            break;
-    }
-}
-
-static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
-{
-    int cur, parent;
-
-    cur = ++(ti->heapnum);
-    memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize);
-    ti->indx[ti->ptr[cur]] = indx;
-    parent = cur/2;
-    while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]],
-                                ti->heap[ti->ptr[cur]]) > 0)
-    {
-        heap_swap (ti, cur, parent);
-        cur = parent;
-        parent = cur/2;
-    }
-}
-
-static
-struct trunc_info *heap_init (int size, int key_size,
-                              int (*cmp)(const void *p1, const void *p2))
-{
-    struct trunc_info *ti = (struct trunc_info *) xmalloc (sizeof(*ti));
-    int i;
-
-    ++size;
-    ti->heapnum = 0;
-    ti->keysize = key_size;
-    ti->cmp = cmp;
-    ti->indx = (int *) xmalloc (size * sizeof(*ti->indx));
-    ti->heap = (char **) xmalloc (size * sizeof(*ti->heap));
-    ti->ptr = (int *) xmalloc (size * sizeof(*ti->ptr));
-    ti->swapbuf = (char *) xmalloc (ti->keysize);
-    ti->tmpbuf = (char *) xmalloc (ti->keysize);
-    ti->buf = (char *) xmalloc (size * ti->keysize);
-    for (i = size; --i >= 0; )
-    {
-        ti->ptr[i] = i;
-        ti->heap[i] = ti->buf + ti->keysize * i;
-    }
-    return ti;
-}
-
-static void heap_close (struct trunc_info *ti)
-{
-    xfree (ti->buf);
-    xfree (ti->ptr);
-    xfree (ti->indx);
-    xfree (ti->heap);
-    xfree (ti->swapbuf);
-    xfree (ti->tmpbuf);
-    xfree (ti);
-}
-
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_m_or_parms *r_parms = (rset_m_or_parms *) parms;
-    struct rset_mor_info *info;
-
-    ct->flags |= RSET_FLAG_VOLATILE;
-    info = (struct rset_mor_info *) xmalloc (sizeof(*info));
-    info->key_size = r_parms->key_size;
-    assert (info->key_size > 1);
-    info->cmp = r_parms->cmp;
-    
-    info->no_save_positions = r_parms->no_save_positions;
-
-    info->isc = r_parms->isc;
-    info->no_isam_positions = r_parms->no_isam_positions;
-    info->isam_positions = (ISAMC_P *)
-	xmalloc (sizeof(*info->isam_positions) * info->no_isam_positions);
-    memcpy (info->isam_positions, r_parms->isam_positions,
-            sizeof(*info->isam_positions) * info->no_isam_positions);
-    info->rfd_list = NULL;
-
-    ct->no_rset_terms = 1;
-    ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
-    ct->rset_terms[0] = r_parms->rset_term;
-    return info;
-}
-
-static RSFD r_open (RSET ct, int flag)
-{
-    struct rset_mor_rfd *rfd;
-    struct rset_mor_info *info = (struct rset_mor_info *) ct->buf;
-    int i;
-
-    if (flag & RSETF_WRITE)
-    {
-	logf (LOG_FATAL, "m_or set type is read-only");
-	return NULL;
-    }
-    rfd = (struct rset_mor_rfd *) xmalloc (sizeof(*rfd));
-    rfd->flag = flag;
-    rfd->next = info->rfd_list;
-    rfd->info = info;
-    info->rfd_list = rfd;
-
-    rfd->ispt = (ISAMC_PP *)
-	xmalloc (sizeof(*rfd->ispt) * info->no_isam_positions);
-        
-    rfd->ti = heap_init (info->no_isam_positions, info->key_size, info->cmp);
-
-    ct->rset_terms[0]->nn = 0;
-    for (i = 0; i<info->no_isam_positions; i++)
-    {
-        rfd->ispt[i] = isc_pp_open (info->isc, info->isam_positions[i]);
-	
-	ct->rset_terms[0]->nn += isc_pp_num (rfd->ispt[i]);
-
-        if (isc_pp_read (rfd->ispt[i], rfd->ti->tmpbuf))
-            heap_insert (rfd->ti, rfd->ti->tmpbuf, i);
-        else
-        {
-            isc_pp_close (rfd->ispt[i]);
-            rfd->ispt[i] = NULL;
-        }
-    }
-    rfd->position = info->no_save_positions;
-    rfd->pbuf = 0;
-    r_rewind (rfd);
-    return rfd;
-}
-
-static void r_close (RSFD rfd)
-{
-    struct rset_mor_info *info = ((struct rset_mor_rfd*)rfd)->info;
-    struct rset_mor_rfd **rfdp;
-    int i;
-    
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-            *rfdp = (*rfdp)->next;
-        
-            heap_close (((struct rset_mor_rfd *) rfd)->ti);
-            for (i = 0; i<info->no_isam_positions; i++)
-                if (((struct rset_mor_rfd *) rfd)->ispt[i])
-                    isc_pp_close (((struct rset_mor_rfd *) rfd)->ispt[i]);
-            xfree (((struct rset_mor_rfd *)rfd)->ispt);
-            xfree (((struct rset_mor_rfd *)rfd)->pbuf);
-            xfree (rfd);
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
-}
-
-static void r_delete (RSET ct)
-{
-    struct rset_mor_info *info = (struct rset_mor_info *) ct->buf;
-    assert (info->rfd_list == NULL);
-    xfree (info->isam_positions);
-    xfree (info);
-}
-
-static void r_rewind (RSFD rfd)
-{
-}
-
-
-static int r_read (RSFD rfd, void *buf)
-{
-    struct rset_mor_rfd *mrfd = (struct rset_mor_rfd *) rfd;
-    struct trunc_info *ti = mrfd->ti;
-    int n = ti->indx[ti->ptr[1]];
-
-    if (!ti->heapnum)
-        return 0;
-    memcpy (buf, ti->heap[ti->ptr[1]], ti->keysize);
-    if (((struct rset_mor_rfd *) rfd)->position)
-    {
-        if (isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf))
-        {
-            heap_delete (ti);
-            if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
-                 ((struct rset_mor_rfd *) rfd)->position--;
-            heap_insert (ti, ti->tmpbuf, n);
-        }
-        else
-            heap_delete (ti);
-    rfd->pbuf = xmalloc (info->key_size);
-        if (mrfd->countp && (
-                *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1))
-        {
-            memcpy (mrfd->pbuf, buf, ti->keysize);
-            (*mrfd->countp)++;
-        }
-        return 1;
-    }
-    while (1)
-    {
-        if (!isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf))
-        {
-            heap_delete (ti);
-            break;
-        }
-        if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
-        {
-            heap_delete (ti);
-            heap_insert (ti, ti->tmpbuf, n);
-            break;
-        }
-    }
-    if (mrfd->countp && (
-            *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1))
-    {
-        memcpy (mrfd->pbuf, buf, ti->keysize);
-        (*mrfd->countp)++;
-    }
-    return 1;
-}
-
-static int r_write (RSFD rfd, const void *buf)
-{
-    logf (LOG_FATAL, "mor set type is read-only");
-    return -1;
-}
diff --git a/rset/rsmultior.c b/rset/rsmultior.c
index 72179e9..70e22b6 100644
--- a/rset/rsmultior.c
+++ b/rset/rsmultior.c
@@ -1,4 +1,4 @@
-/* $Id: rsmultior.c,v 1.7 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsmultior.c,v 1.8 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
    Index Data Aps
 
@@ -38,7 +38,7 @@ static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
 static int r_read (RSFD rfd, void *buf);
 static int r_write (RSFD rfd, const void *buf);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf);
 static void r_pos (RSFD rfd, double *current, double *total);
@@ -46,9 +46,9 @@ static void r_pos (RSFD rfd, double *current, double *total);
 static const struct rset_control control = 
 {
     "multi-or",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward,
     r_pos,
@@ -88,11 +88,6 @@ struct rset_multior_info {
     int     (*cmp)(const void *p1, const void *p2);
     int     no_rsets;
     RSET    *rsets;
-    struct rset_multior_rfd *rfd_list; /* rfds in use */
-    struct rset_multior_rfd *free_list; /* rfds free */
-        /* rfds are allocated when first opened, if nothing in freelist */
-        /* when allocated, all their pointers are allocated as well, and */
-        /* those are kept intact when in the freelist, ready to be reused */
 };
 
 
@@ -100,8 +95,6 @@ struct rset_multior_rfd {
     int flag;
     struct heap_item *items; /* we alloc and free them here */
     HEAP h;
-    struct rset_multior_rfd *next;
-    struct rset_multior_info *info;
     zint hits; /* returned so far */
     char *prevvalue; /* to see if we are in another record */
       /* FIXME - is this really needed? */
@@ -238,8 +231,6 @@ RSET rsmultior_create( NMEM nmem, int key_size,
     info->no_rsets=no_rsets;
     info->rsets=(RSET*)nmem_malloc(rnew->nmem, no_rsets*sizeof(*rsets));
     memcpy(info->rsets,rsets,no_rsets*sizeof(*rsets));
-    info->rfd_list = NULL;
-    info->free_list = NULL;
     rnew->priv=info;
     return rnew;
 }
@@ -248,30 +239,14 @@ static void r_delete (RSET ct)
 {
     struct rset_multior_info *info = (struct rset_multior_info *) ct->priv;
     int i;
-
-    assert (info->rfd_list == NULL);
     for(i=0;i<info->no_rsets;i++)
         rset_delete(info->rsets[i]);
 }
-#if 0
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
-    rset_multior_parms *r_parms = (rset_multior_parms *) parms;
-    struct rset_multior_info *info;
-    info = (struct rset_multior_info *) xmalloc (sizeof(*info));
-    info->key_size = r_parms->key_size;
-    assert (info->key_size > 1);
-    info->cmp = r_parms->cmp;
-    info->no_rsets= r_parms->no_rsets;
-    info->rsets=r_parms->rsets; /* now we own it! */
-    info->rfd_list=0;
-    return info;
-}
-#endif
 
 static RSFD r_open (RSET ct, int flag)
 {
-    struct rset_multior_rfd *rfd;
+    RSFD rfd;
+    struct rset_multior_rfd *p;
     struct rset_multior_info *info = (struct rset_multior_info *) ct->priv;
     int i;
 
@@ -280,62 +255,47 @@ static RSFD r_open (RSET ct, int flag)
         logf (LOG_FATAL, "multior set type is read-only");
         return NULL;
     }
-    rfd=info->free_list;
-    if (rfd) {
-        info->free_list=rfd->next;
-        heap_clear(rfd->h);
-        assert(rfd->items);
+    rfd=rfd_create_base(ct);
+    if (rfd->priv) {
+        p=(struct rset_multior_rfd *)rfd->priv;
+        heap_clear(p->h);
+        assert(p->items);
         /* all other pointers shouls already be allocated, in right sizes! */
     }
     else {
-        rfd = (struct rset_multior_rfd *) nmem_malloc (ct->nmem,sizeof(*rfd));
-        rfd->h = heap_create( ct->nmem, info->no_rsets, 
+        p = (struct rset_multior_rfd *) nmem_malloc (ct->nmem,sizeof(*p));
+        rfd->priv=p;
+        p->h = heap_create( ct->nmem, info->no_rsets, 
                               info->key_size, info->cmp);
-        rfd->items=(struct heap_item *) nmem_malloc(ct->nmem,
-                              info->no_rsets*sizeof(*rfd->items));
+        p->items=(struct heap_item *) nmem_malloc(ct->nmem,
+                              info->no_rsets*sizeof(*p->items));
         for (i=0; i<info->no_rsets; i++){
-            rfd->items[i].rset=info->rsets[i];
-            rfd->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
+            p->items[i].rset=info->rsets[i];
+            p->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
         }
     }
-    rfd->flag = flag;
-    rfd->next = info->rfd_list;
-    rfd->info = info;
-    info->rfd_list = rfd;
-    rfd->prevvalue=0;
-    rfd->hits=0;
+    p->flag = flag;
+    p->prevvalue=0;
+    p->hits=0;
     for (i=0; i<info->no_rsets; i++){
-        rfd->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
-        if ( rset_read(rfd->items[i].rset, rfd->items[i].fd, 
-                      rfd->items[i].buf) )
-            heap_insert(rfd->h, &(rfd->items[i]));
+        p->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
+        if ( rset_read(p->items[i].fd, p->items[i].buf) )
+            heap_insert(p->h, &(p->items[i]));
     }
     return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
-    struct rset_multior_info *info = mrfd->info;
-    struct rset_multior_rfd **rfdp;
+    struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+    struct rset_multior_rfd *p=(struct rset_multior_rfd *)(rfd->priv);
     int i;
-    
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-            *rfdp = (*rfdp)->next;
-        
-            heap_destroy (mrfd->h);
-            for (i = 0; i<info->no_rsets; i++) {
-                if (mrfd->items[i].fd)
-                    rset_close(info->rsets[i],mrfd->items[i].fd);
-            }
-            mrfd->next=info->free_list;
-            info->free_list=mrfd;
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+
+    heap_destroy (p->h);
+    for (i = 0; i<info->no_rsets; i++) 
+        if (p->items[i].fd)
+            rset_close(p->items[i].fd);
+    rfd_delete_base(rfd);
 }
 
 
@@ -345,25 +305,25 @@ static void r_rewind (RSFD rfd)
 }
 
 
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf)
 {
-    struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
-    struct rset_multior_info *info = mrfd->info;
+    struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+    struct rset_multior_rfd *mrfd=(struct rset_multior_rfd *)(rfd->priv);
     struct heap_item it;
     int rdres;
     if (heap_empty(mrfd->h))
         return 0;
     if (cmpfunc)
-        assert(cmpfunc==mrfd->info->cmp);
+        assert(cmpfunc==info->cmp);
     it = *(mrfd->h->heap[1]);
     memcpy(buf,it.buf, info->key_size); 
     (mrfd->hits)++;
     if (untilbuf)
-        rdres=rset_forward(it.rset, it.fd, it.buf, cmpfunc,untilbuf);
+        rdres=rset_forward(it.fd, it.buf, cmpfunc,untilbuf);
     else
-        rdres=rset_read(it.rset, it.fd, it.buf);
+        rdres=rset_read(it.fd, it.buf);
     if ( rdres )
         heap_balance(mrfd->h);
     else
@@ -374,18 +334,18 @@ static int r_forward(RSET ct, RSFD rfd, void *buf,
 
 static int r_read (RSFD rfd, void *buf)
 {
-    return r_forward(0,rfd, buf,0,0);
+    return r_forward(rfd, buf,0,0);
 }
 
 static void r_pos (RSFD rfd, double *current, double *total)
 {
-    struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
-    struct rset_multior_info *info = mrfd->info;
+    struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+    struct rset_multior_rfd *mrfd=(struct rset_multior_rfd *)(rfd->priv);
     double cur, tot;
     double scur=0.0, stot=0.0;
     int i;
     for (i=0; i<info->no_rsets; i++){
-        rset_pos(mrfd->items[i].rset, mrfd->items[i].fd, &cur, &tot);
+        rset_pos(mrfd->items[i].fd, &cur, &tot);
         logf(LOG_LOG, "r_pos: %d %0.1f %0.1f", i, cur,tot);
         scur += cur;
         stot += tot;
diff --git a/rset/rsnull.c b/rset/rsnull.c
index 29322af..4bd90c6 100644
--- a/rset/rsnull.c
+++ b/rset/rsnull.c
@@ -1,4 +1,4 @@
-/* $Id: rsnull.c,v 1.23 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsnull.c,v 1.24 2004-08-31 10:43:39 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
    Index Data Aps
 
@@ -27,7 +27,6 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include <zebrautl.h>
 #include <rsnull.h>
 
-/* FIXME - Use the nmem instead of xmalloc all the way through */
 
 static RSFD r_open (RSET ct, int flag);
 static void r_close (RSFD rfd);
@@ -40,9 +39,9 @@ static int r_write (RSFD rfd, const void *buf);
 static const struct rset_control control = 
 {
     "null",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     rset_default_forward,
     r_pos,
@@ -59,25 +58,22 @@ RSET rsnull_create(NMEM nmem )
     return rnew;
 }
 
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
-    return NULL;
-}
-#endif
-
 static RSFD r_open (RSET ct, int flag)
 {
+    RSFD rfd;
     if (flag & RSETF_WRITE)
     {
         logf (LOG_FATAL, "NULL set type is read-only");
         return NULL;
     }
-    return "";
+    rfd=rfd_create_base(ct);
+    rfd->priv=NULL; 
+    return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
+    rfd_delete_base(rfd);
 }
 
 static void r_delete (RSET ct)
diff --git a/rset/rsprox.c b/rset/rsprox.c
index 8276e83..d7618fa 100644
--- a/rset/rsprox.c
+++ b/rset/rsprox.c
@@ -1,4 +1,4 @@
-/* $Id: rsprox.c,v 1.12 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsprox.c,v 1.13 2004-08-31 10:43:40 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
    Index Data Aps
 
@@ -36,7 +36,7 @@ static RSFD r_open (RSET ct, int flag);
 static void r_close (RSFD rfd);
 static void r_delete (RSET ct);
 static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf, 
+static int r_forward(RSFD rfd, void *buf, 
                      int (*cmpfunc)(const void *p1, const void *p2),
                      const void *untilbuf);
 static int r_read (RSFD rfd, void *buf);
@@ -46,9 +46,9 @@ static void r_pos (RSFD rfd, double *current, double *total);
 static const struct rset_control control = 
 {
     "prox",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     r_forward,
     r_pos,
@@ -69,16 +69,12 @@ struct rset_prox_info {
     int key_size;
     int (*cmp)(const void *p1, const void *p2);
     int (*getseq)(const void *p);
-    struct rset_prox_rfd *rfd_list;
-    struct rset_prox_rfd *free_list;
 };
 
 struct rset_prox_rfd {
     RSFD *rfd;
     char **buf;  /* lookahead key buffers */
     char *more;  /* more in each lookahead? */
-    struct rset_prox_rfd *next;
-    struct rset_prox_info *info;
     zint hits;
 };    
 
@@ -104,8 +100,6 @@ RSET rsprox_create( NMEM nmem, int key_size,
     info->exclusion=exclusion;
     info->relation=relation;
     info->distance=distance;
-    info->rfd_list = NULL;
-    info->free_list = NULL;
     rnew->priv=info;
     return rnew;
 }
@@ -116,7 +110,6 @@ static void r_delete (RSET ct)
     struct rset_prox_info *info = (struct rset_prox_info *) ct->priv;
     int i;
 
-    assert (info->rfd_list == NULL);
     for (i = 0; i<info->rset_no; i++)
         rset_delete (info->rset[i]);
 }
@@ -125,7 +118,8 @@ static void r_delete (RSET ct)
 static RSFD r_open (RSET ct, int flag)
 {
     struct rset_prox_info *info = (struct rset_prox_info *) ct->priv;
-    struct rset_prox_rfd *rfd;
+    RSFD rfd;
+    struct rset_prox_rfd *p;
     int i;
 
     if (flag & RSETF_WRITE)
@@ -133,87 +127,70 @@ static RSFD r_open (RSET ct, int flag)
         logf (LOG_FATAL, "prox set type is read-only");
         return NULL;
     }
-    rfd = info->free_list;
-    if (rfd)
-        info->free_list=rfd->next;
+    rfd = rfd_create_base(ct);
+    if (rfd->priv)
+        p=(struct rset_prox_rfd *)(rfd->priv);
     else {
-        rfd = (struct rset_prox_rfd *) xmalloc (sizeof(*rfd));
-        rfd->more = nmem_malloc (ct->nmem,sizeof(*rfd->more) * info->rset_no);
-        rfd->buf = nmem_malloc(ct->nmem,sizeof(*rfd->buf) * info->rset_no);
+        p = (struct rset_prox_rfd *) nmem_malloc (ct->nmem,sizeof(*p));
+        rfd->priv=p;
+        p->more = nmem_malloc (ct->nmem,sizeof(*p->more) * info->rset_no);
+        p->buf = nmem_malloc(ct->nmem,sizeof(*p->buf) * info->rset_no);
         for (i = 0; i < info->rset_no; i++)
-            rfd->buf[i] = nmem_malloc(ct->nmem,info->key_size);
-        rfd->rfd = nmem_malloc(ct->nmem,sizeof(*rfd->rfd) * info->rset_no);
+            p->buf[i] = nmem_malloc(ct->nmem,info->key_size);
+        p->rfd = nmem_malloc(ct->nmem,sizeof(*p->rfd) * info->rset_no);
     }
     logf(LOG_DEBUG,"rsprox (%s) open [%p]", ct->control->desc, rfd);
-    rfd->next = info->rfd_list;
-    info->rfd_list = rfd;
-    rfd->info = info;
-
 
     for (i = 0; i < info->rset_no; i++) {
-        rfd->rfd[i] = rset_open (info->rset[i], RSETF_READ);
-        rfd->more[i] = rset_read (info->rset[i], rfd->rfd[i],
-                                  rfd->buf[i]);
+        p->rfd[i] = rset_open (info->rset[i], RSETF_READ);
+        p->more[i] = rset_read (p->rfd[i], p->buf[i]);
     }
-    rfd->hits=0;
+    p->hits=0;
     return rfd;
 }
 
 static void r_close (RSFD rfd)
 {
-    struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
-    struct rset_prox_rfd **rfdp;
+    struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+    struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
     
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-            int i;
-            struct rset_prox_rfd *rfd_tmp=*rfdp;
-            for (i = 0; i<info->rset_no; i++)
-                rset_close (info->rset[i], (*rfdp)->rfd[i]);
-            *rfdp = (*rfdp)->next;
-            rfd_tmp->next=info->free_list;
-            info->free_list=rfd_tmp;
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    int i;
+    for (i = 0; i<info->rset_no; i++)
+        rset_close (p->rfd[i]);
+    rfd_delete_base(rfd);
 }
 
 static void r_rewind (RSFD rfd)
 {
-    struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
-    struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+    struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+    struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
     int i;
 
     logf (LOG_DEBUG, "rsprox_rewind");
 
     for (i = 0; i < info->rset_no; i++)
     {
-        rset_rewind (info->rset[i], p->rfd[i]);
-        p->more[i] = rset_read (info->rset[i], p->rfd[i], p->buf[i]);
+        rset_rewind (p->rfd[i]);
+        p->more[i] = rset_read (p->rfd[i], p->buf[i]);
     }
     p->hits=0;
 }
 
-static int r_forward (RSET ct, RSFD rfd, void *buf, 
+static int r_forward (RSFD rfd, void *buf, 
                       int (*cmpfunc)(const void *p1, const void *p2),
                       const void *untilbuf)
 {
-    /* Note: CT is not used. We _can_ pass NULL for it */
-    struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
-    struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+    struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+    struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
     int cmp=0;
     int i;
 
     if (untilbuf)
     {
-        /* it's enough to forward first one. Other will follow
-           automatically */
+        /* it is enough to forward first one. Other will follow. */
         if ( p->more[0] && ((cmpfunc)(untilbuf, p->buf[0]) >= 2) )
-            p->more[0] = rset_forward(info->rset[0], p->rfd[0],
-                                      p->buf[0], info->cmp,
-                                      untilbuf);
+            p->more[0] = rset_forward(p->rfd[0], p->buf[0], 
+                                      info->cmp, untilbuf);
     }
     if (info->ordered && info->relation == 3 && info->exclusion == 0
         && info->distance == 1)
@@ -224,14 +201,13 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
             {
                 if (!p->more[i]) 
                 {
-                    p->more[0] = 0;    /* saves us a goto out of while loop. */
+                    p->more[0] = 0; /* saves us a goto out of while loop. */
                     break;
                 }
                 cmp = (*info->cmp) (p->buf[i], p->buf[i-1]);
                 if (cmp > 1)
                 {
-                    p->more[i-1] = rset_forward (info->rset[i-1],
-                                                 p->rfd[i-1],
+                    p->more[i-1] = rset_forward (p->rfd[i-1],
                                                  p->buf[i-1],
                                                  info->cmp,
                                                  p->buf[i]);
@@ -241,24 +217,22 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
                 {
                     if ((*info->getseq)(p->buf[i-1]) +1 != 
                         (*info->getseq)(p->buf[i]))
-                    {
-                        p->more[i-1] = rset_read ( info->rset[i-1], 
-                                             p->rfd[i-1], p->buf[i-1]);
+                    { /* FIXME - We need more flexible multilevel stuff */
+                        p->more[i-1] = rset_read ( p->rfd[i-1], p->buf[i-1]);
                         break;
                     }
                 }
                 else
                 {
-                    p->more[i] = rset_forward (info->rset[i], p->rfd[i],
-                                               p->buf[i], info->cmp,
-                                               p->buf[i-1]);
+                    p->more[i] = rset_forward (p->rfd[i], p->buf[i], 
+                                               info->cmp, p->buf[i-1]);
                     break;
                 }
             }
-            if (i == p->info->rset_no)
+            if (i == info->rset_no)
             {
                 memcpy (buf, p->buf[0], info->key_size);
-                p->more[0] = rset_read (info->rset[0], p->rfd[0], p->buf[0]);
+                p->more[0] = rset_read (p->rfd[0], p->buf[0]);
                 p->hits++;
                 return 1;
             }
@@ -270,10 +244,10 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
         {
             int cmp = (*info->cmp)(p->buf[0], p->buf[1]);
             if (cmp < -1)
-                p->more[0] = rset_forward (info->rset[0], p->rfd[0],
+                p->more[0] = rset_forward (p->rfd[0],
                                            p->buf[0], info->cmp, p->buf[0]);
             else if (cmp > 1)
-                p->more[1] = rset_forward (info->rset[1], p->rfd[1],
+                p->more[1] = rset_forward (p->rfd[1],
                                            p->buf[1], info->cmp, p->buf[1]);
             else
             {
@@ -281,7 +255,7 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
                 int n = 0;
                 
                 seqno[n++] = (*info->getseq)(p->buf[0]);
-                while ((p->more[0] = rset_read (info->rset[0], p->rfd[0],
+                while ((p->more[0] = rset_read (p->rfd[0],
                                                 p->buf[0])) >= -1 &&
                        p->more[0] <= -1)
                     if (n < 500)
@@ -324,14 +298,12 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
                     {
                         memcpy (buf, p->buf[1], info->key_size);
                         
-                        p->more[1] = rset_read (info->rset[1],
-                                                p->rfd[1], p->buf[1]);
+                        p->more[1] = rset_read ( p->rfd[1], p->buf[1]);
                         p->hits++;
                         return 1;
                     }
                 }
-                p->more[1] = rset_read (info->rset[1], p->rfd[1],
-                                        p->buf[1]);
+                p->more[1] = rset_read (p->rfd[1], p->buf[1]);
             }
         }
     }
@@ -341,8 +313,7 @@ static int r_forward (RSET ct, RSFD rfd, void *buf,
 
 static int r_read (RSFD rfd, void *buf)
 {
-    { double cur,tot; r_pos(rfd,&cur,&tot); } /*!*/
-    return r_forward(0, rfd, buf, 0, 0);
+    return r_forward(rfd, buf, 0, 0);
 }
 
 static int r_write (RSFD rfd, const void *buf)
@@ -353,8 +324,8 @@ static int r_write (RSFD rfd, const void *buf)
 
 static void r_pos (RSFD rfd, double *current, double *total)
 {
-    struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
-    struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+    struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+    struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
     int i;
     double cur,tot=-1;
     double scur=0,stot=0;
@@ -364,7 +335,7 @@ static void r_pos (RSFD rfd, double *current, double *total)
 
     for (i = 0; i < info->rset_no; i++)
     {
-        rset_pos(info->rset[i], p->rfd[i],  &cur, &tot);
+        rset_pos(p->rfd[i],  &cur, &tot);
         if (tot>0) {
             scur += cur;
             stot += tot;
diff --git a/rset/rstemp.c b/rset/rstemp.c
index f77479d..4450132 100644
--- a/rset/rstemp.c
+++ b/rset/rstemp.c
@@ -1,4 +1,4 @@
-/* $Id: rstemp.c,v 1.46 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rstemp.c,v 1.47 2004-08-31 10:43:40 heikki Exp $
    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
    Index Data Aps
 
@@ -46,9 +46,9 @@ static void r_pos (RSFD rfd, double *current, double  *total);
 static const struct rset_control control = 
 {
     "temp",
+    r_delete,
     r_open,
     r_close,
-    r_delete,
     r_rewind,
     rset_default_forward,
     r_pos, 
@@ -71,15 +71,12 @@ struct rset_temp_info {
     zint     hits;          /* no of hits */
     char   *temp_path;
     int     (*cmp)(const void *p1, const void *p2);
-    struct rset_temp_rfd *rfd_list;  /* rfds in use */
-    struct rset_temp_rfd *free_list; /* fully alloc'd rfds waiting for reuse*/
 };
 
 struct rset_temp_rfd {
-    struct rset_temp_info *info;
-    struct rset_temp_rfd *next;
     void *buf;
     size_t  pos_cur;       /* current position in set */
+                           /* FIXME - term pos or what ??  */
     zint cur; /* number of the current hit */
 };
 
@@ -101,8 +98,6 @@ RSET rstemp_create( NMEM nmem, int key_size,
     info->dirty = 0;
     info->hits = 0;
     info->cmp = cmp;
-    info->rfd_list = NULL;
-    info->free_list = NULL;
 
     if (!temp_path)
         info->temp_path = NULL;
@@ -135,7 +130,8 @@ static void r_delete (RSET ct)
 static RSFD r_open (RSET ct, int flag)
 {
     struct rset_temp_info *info = (struct rset_temp_info *) ct->priv;
-    struct rset_temp_rfd *rfd;
+    RSFD rfd;
+    struct rset_temp_rfd *prfd;
 
     if (info->fd == -1 && info->fname)
     {
@@ -149,18 +145,13 @@ static RSFD r_open (RSET ct, int flag)
             exit (1);
         }
     }
-    rfd = info->free_list;
-    if (rfd)
-        info->free_list=rfd->next;
-    else {
-        rfd = (struct rset_temp_rfd *) xmalloc (sizeof(*rfd));
-        rfd->buf = xmalloc (info->key_size);
+    rfd = rfd_create_base(ct);
+    if (!rfd->priv){
+        prfd= (struct rset_temp_rfd *) nmem_malloc(ct->nmem, sizeof(*prfd));
+        rfd->priv=(void *)prfd;
+        prfd->buf = nmem_malloc (ct->nmem,info->key_size);
     }
-    rfd->next = info->rfd_list;
-    info->rfd_list = rfd;
-    rfd->info = info;
     r_rewind (rfd);
-
     return rfd;
 }
 
@@ -169,7 +160,8 @@ static RSFD r_open (RSET ct, int flag)
  */
 static void r_flush (RSFD rfd, int mk)
 {
-    struct rset_temp_info *info = ((struct rset_temp_rfd*) rfd)->info;
+    /* struct rset_temp_info *info = ((struct rset_temp_rfd*) rfd)->info; */
+    struct rset_temp_info *info = rfd->rset->priv;
 
     if (!info->fname && mk)
     {
@@ -232,27 +224,15 @@ static void r_flush (RSFD rfd, int mk)
 
 static void r_close (RSFD rfd)
 {
-    struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
-    struct rset_temp_rfd **rfdp;
-
-    for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
-        if (*rfdp == rfd)
-        {
-            struct rset_temp_rfd *rfd_tmp=*rfdp;
-            r_flush (*rfdp, 0);
-            *rfdp = (*rfdp)->next;
-            rfd_tmp->next=info->free_list;
-            info->free_list=rfd_tmp;
-
-            if (!info->rfd_list && info->fname && info->fd != -1)
-            {
-                close (info->fd);
-                info->fd = -1;
-            }
-            return;
-        }
-    logf (LOG_FATAL, "r_close but no rfd match!");
-    assert (0);
+    /*struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv; */
+    struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+    r_flush (rfd, 0);
+    if (info->fname && info->fd != -1)
+    {
+        close (info->fd);
+        info->fd = -1;
+    } /* FIXME - Is this right, don't we risk closing the file too early ?*/
+    rfd_delete_base(rfd);
 }
 
 
@@ -262,14 +242,15 @@ static void r_close (RSFD rfd)
  */
 static void r_reread (RSFD rfd)
 {
-    struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
+    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv; 
+    struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
 
     if (info->fname)
     {
         size_t count;
         int r;
 
-        info->pos_border = ((struct rset_temp_rfd *)rfd)->pos_cur +
+        info->pos_border = mrfd->pos_cur +
             info->buf_size;
         if (info->pos_border > info->pos_end)
             info->pos_border = info->pos_end;
@@ -298,27 +279,19 @@ static void r_reread (RSFD rfd)
 
 static void r_rewind (RSFD rfd)
 {
-    struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
-
+    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) (rfd->priv);  
+    struct rset_temp_info *info = (struct rset_temp_info *)(rfd->rset->priv);
     r_flush (rfd, 0);
-    ((struct rset_temp_rfd *)rfd)->pos_cur = 0;
+    mrfd->pos_cur = 0;
     info->pos_buf = 0;
     r_reread (rfd);
-    ((struct rset_temp_rfd *)rfd)->cur=0;
+    mrfd->cur=0;
 }
 
-/*
-static int r_count (RSET ct)
-{
-    struct rset_temp_info *info = (struct rset_temp_info *) ct->buf;
-
-    return info->pos_end / info->key_size;
-}
-*/
 static int r_read (RSFD rfd, void *buf)
 {
-    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
-    struct rset_temp_info *info = mrfd->info;
+    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;  
+    struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
 
     size_t nc = mrfd->pos_cur + info->key_size;
 
@@ -339,8 +312,8 @@ static int r_read (RSFD rfd, void *buf)
 
 static int r_write (RSFD rfd, const void *buf)
 {
-    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
-    struct rset_temp_info *info = mrfd->info;
+    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;  
+    struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
 
     size_t nc = mrfd->pos_cur + info->key_size;
 
@@ -363,7 +336,10 @@ static int r_write (RSFD rfd, const void *buf)
 
 static void r_pos (RSFD rfd, double  *current, double  *total)
 {
-    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
+    /* struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd; */
+    struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;  
+    struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+    
     *current=(double) mrfd->cur;
-    *total=(double) mrfd->info->hits;
+    *total=(double) info->hits;
 }