-/* $Id: rsbetween.h,v 1.6 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsbetween.h,v 1.7 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
+#error "do not use rsbetween.h, it all is in rset.h"
RSET rsbetween_create( NMEM nmem, int key_size,
int (*cmp)(const void *p1, const void *p2),
RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr,
-/* $Id: rsbool.h,v 1.10 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsbool.h,v 1.11 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
extern "C" {
#endif
+#error "rsbool.h no longer needed, use rset.h insted"
+
RSET rsbool_create_and( NMEM nmem, int key_size,
int (*cmp)(const void *p1, const void *p2),
RSET rset_l, RSET rset_r,
-/* $Id: rset.h,v 1.32 2004-08-31 10:43:35 heikki Exp $
+/* $Id: rset.h,v 1.33 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <stdlib.h>
+/* unfortunately we need the isam includes here, for the arguments for */
+/* rsisamX_create */
+#include <isamb.h>
+#include <isamc.h>
+#include <isams.h>
+
#ifdef __cplusplus
extern "C" {
#endif
RSFD (*f_open)(RSET ct, int wflag);
void (*f_close)(RSFD rfd);
void (*f_rewind)(RSFD rfd);
- int (*f_forward)(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf);
+ int (*f_forward)(RSFD rfd, void *buf, const void *untilbuf);
void (*f_pos)(RSFD rfd, double *current, double *total);
/* returns -1,-1 if pos function not implemented for this type */
int (*f_read)(RSFD rfd, void *buf);
};
int rset_default_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
+struct key_control {
+ int key_size;
+ int (*cmp) (const void *p1, const void *p2);
+ void (*key_logdump_txt) (int logmask, const void *p, const char *txt);
+ zint (*getseq)(const void *p);
+ /* FIXME - Should not need a getseq, it won't make much sense with */
+ /* higher-order keys. Use a (generalized) cmp instead, or something */
+ /* FIXME - decode and encode, and lots of other stuff */
+};
typedef struct rset
{
const struct rset_control *control;
+ const struct key_control *keycontrol;
int count; /* reference count */
void *priv; /* stuff private to the given type of rset */
NMEM nmem; /* nibble memory for various allocs */
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_base(const struct rset_control *sel,
+ NMEM nmem,
+ const struct key_control *kcontrol);
void rset_delete(RSET rs);
RSET rset_dup (RSET rs);
#define rset_rewind(rfd) (*(rfd)->rset->control->f_rewind)((rfd))
/* 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 */
+#define rset_forward(rfd, buf, untilbuf) \
+ (*(rfd)->rset->control->f_forward)((rfd),(buf),(untilbuf))
/* int rset_pos(RSFD fd, double *current, double *total); */
#define rset_pos(rfd,cur,tot) \
/* int rset_type (RSET) */
#define rset_type(rs) ((rs)->control->desc)
+RSET rstemp_create( NMEM nmem, const struct key_control *kcontrol,
+ const char *temp_path);
+
+RSET rsnull_create(NMEM nmem, const struct key_control *kcontrol);
+
+RSET rsbool_create_and( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r);
+
+RSET rsbool_create_or ( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r);
+
+RSET rsbool_create_not( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r);
+
+RSET rsbetween_create( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_m, RSET rset_r,
+ RSET rset_attr);
+
+RSET rsmultior_create( NMEM nmem, const struct key_control *kcontrol,
+ int no_rsets, RSET* rsets);
+
+RSET rsprox_create( NMEM nmem, const struct key_control *kcontrol,
+ int rset_no, RSET *rset,
+ int ordered, int exclusion,
+ int relation, int distance);
+
+RSET rsisamb_create( NMEM nmem, const struct key_control *kcontrol,
+ ISAMB is, ISAMB_P pos);
+
+RSET rsisamc_create( NMEM nmem, const struct key_control *kcontrol,
+ ISAMC is, ISAMC_P pos);
+
+RSET rsisams_create( NMEM nmem, const struct key_control *kcontrol,
+ ISAMS is, ISAMS_P pos);
+
+
#ifdef __cplusplus
}
-/* $Id: rsisamb.h,v 1.4 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsisamb.h,v 1.5 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
+#error "Never mind rsisamb.h, it is all in rset.h "
/* extern const struct rset_control *rset_kind_isamb; */
RSET rsisamb_create( NMEM nmem, int key_size,
-/* $Id: rsisamc.h,v 1.9 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsisamc.h,v 1.10 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
+#error "do not use rsisamc.h any more, rset.h covers it all "
extern const struct rset_control *rset_kind_isamc;
RSET rsisamc_create( NMEM nmem, int key_size,
-/* $Id: rsisams.h,v 1.4 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsisams.h,v 1.5 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
+#error "do not use rsisams.h, it is all in rset.h"
extern const struct rset_control *rset_kind_isams;
RSET rsisams_create( NMEM nmem, int key_size,
-/* $Id: rsmultior.h,v 1.4 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsmultior.h,v 1.5 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <rset.h>
+#error "do not use rsmultior.h any more, it is all in rset.h"
YAZ_BEGIN_CDECL
RSET rsmultior_create( NMEM nmem, int key_size,
-/* $Id: rsnull.h,v 1.7 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsnull.h,v 1.8 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
+#error "rsnull.h not used any more, use rset.h instead"
RSET rsnull_create(NMEM nmem);
#ifdef __cplusplus
-/* $Id: rsprox.h,v 1.2 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rsprox.h,v 1.3 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
extern "C" {
#endif
+#error "Do not use rsprox.h, it is all in rset.h"
+
RSET rsprox_create( NMEM nmem, int key_size,
int (*cmp)(const void *p1, const void *p2),
int (*getseq)(const void *p),
-/* $Id: rstemp.h,v 1.11 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rstemp.h,v 1.12 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
-RSET rstemp_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
+#error "rstemp.h should no longer be used, its stuff is in rset.h"
+/* moved into rset.h, this is too simple to keep in a file of its own */
+/*
+RSET rstemp_create( NMEM nmem, const struct key_control *kcontrol,
const char *temp_path);
-/*
-extern const struct rset_control *rset_kind_temp;
-
-typedef struct rset_temp_parms
-{
- int (*cmp)(const void *p1, const void *p2);
- int key_size;
- const char *temp_path;
-} rset_temp_parms;
*/
#ifdef __cplusplus
-/* $Id: index.h,v 1.116 2004-08-31 14:43:41 heikki Exp $
+/* $Id: index.h,v 1.117 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
};
#endif
-struct key_info {
- int keysize;
- int (*key_compare) (const void *p1, const void *p2);
- void (*key_logdump_txt) (int logmask, const void *p, const char *txt);
- /* FIXME - decode and encode, and lots of other stuff */
-};
enum dirsKind { dirs_dir, dirs_file };
int key_compare (const void *p1, const void *p2);
void key_init(struct it_key *k);
char *key_print_it (const void *p, char *buf);
-int key_get_seq (const void *p);
+zint key_get_seq (const void *p);
int key_compare_it (const void *p1, const void *p2);
int key_qsort_compare (const void *p1, const void *p2);
void key_logdump (int mask, const void *p);
RSET rset_trunc (ZebraHandle zh, ISAMS_P *isam_p, int no,
const char *term, int length_term, const char *flags,
- int preserve_position, int term_type, NMEM rset_nmem);
+ int preserve_position, int term_type, NMEM rset_nmem,
+ const struct key_control *kctrl);
void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
const char *db, int set,
-/* $Id: kcompare.c,v 1.50 2004-08-06 12:28:22 adam Exp $
+/* $Id: kcompare.c,v 1.51 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
return 0;
}
-int key_get_seq(const void *p)
+zint key_get_seq(const void *p)
{
struct it_key k;
memcpy (&k, p, sizeof(k));
#if IT_KEY_NEW
- return (int) k.mem[k.len-1];
+ return k.mem[k.len-1];
#else
return k.seqno;
#endif
-/* $Id: trunc.c,v 1.41 2004-08-31 14:43:41 heikki Exp $
+/* $Id: trunc.c,v 1.42 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <assert.h>
#include "index.h"
-#include <rstemp.h>
-#include <rsnull.h>
-#include <rsisams.h>
-#include <rsisamc.h>
-#include <rsisamb.h>
-#include <rsmultior.h>
+#include <rset.h>
struct trunc_info {
int *ptr;
static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
const char *flags, ISAMS_P *isam_p, int from, int to,
int merge_chunk, int preserve_position,
- int term_type, NMEM rset_nmem)
+ int term_type, NMEM rset_nmem,
+ const struct key_control *kctrl)
{
RSET result;
RSFD result_rsfd;
parms.temp_path = res_get (zi->res, "setTmpDir");
result = rset_create (rset_kind_temp, &parms);
*/
- result=rstemp_create( rset_nmem, /* NULL, FIXME - use a proper nmem */
- sizeof(struct it_key), key_compare_it,
+ result=rstemp_create( rset_nmem,kctrl,
res_get (zi->res, "setTmpDir"));
result_rsfd = rset_open (result, RSETF_WRITE);
rset[rscur] = rset_trunc_r (zi, term, length, flags,
isam_p, i, i+i_add,
merge_chunk, preserve_position,
- term_type, rset_nmem);
+ term_type, rset_nmem, kctrl);
else
rset[rscur] = rset_trunc_r (zi, term, length, flags,
isam_p, i, to,
merge_chunk, preserve_position,
- term_type, rset_nmem);
+ term_type, rset_nmem, kctrl);
rscur++;
}
ti = heap_init (rscur, sizeof(struct it_key), key_compare_it);
RSET rset_trunc (ZebraHandle zi, ISAMS_P *isam_p, int no,
const char *term, int length, const char *flags,
- int preserve_position, int term_type, NMEM rset_nmem)
+ int preserve_position, int term_type, NMEM rset_nmem,
+ const struct key_control *kctrl)
{
logf (LOG_DEBUG, "rset_trunc no=%d", no);
if (no < 1)
- return rsnull_create (rset_nmem); /* FIXME - use a proper nmem */
+ return rsnull_create (rset_nmem,kctrl);
if (zi->reg->isams)
{
if (no == 1)
- return rsisams_create(rset_nmem, /* FIXME - use some nmem */
- sizeof(struct it_key), key_compare_it,
+ return rsisams_create(rset_nmem, kctrl,
zi->reg->isams, *isam_p);
- /*
- {
- rset_isams_parms parms;
-
- parms.pos = *isam_p;
- parms.is = zi->reg->isams;
- return rset_create (rset_kind_isams, &parms);
- }
- */
qsort (isam_p, no, sizeof(*isam_p), isams_trunc_cmp);
}
else if (zi->reg->isamc)
{
if (no == 1)
- return rsisamc_create(rset_nmem, /* FIXME - use some nmem */
- sizeof(struct it_key), key_compare_it,
+ return rsisamc_create(rset_nmem, kctrl,
zi->reg->isamc, *isam_p);
- /*
- {
- rset_isamc_parms parms;
-
- parms.key_size = sizeof(struct it_key);
- parms.cmp = key_compare_it;
- parms.pos = *isam_p;
- parms.is = zi->reg->isamc;
- return rset_create (rset_kind_isamc, &parms);
- }
- */
#if 0 /* NEW_TRUNC */ /* FIXME - Use the new multi_or instead !! */
else if (no < 10000)
else if (zi->reg->isamb)
{
if (no == 1)
- return rsisamb_create(rset_nmem, /* FIXME - use some nmem */
- sizeof(struct it_key), key_compare_it,
+ return rsisamb_create(rset_nmem,kctrl,
zi->reg->isamb, *isam_p);
- /*
- {
- rset_isamb_parms parms;
- parms.key_size = sizeof(struct it_key);
- parms.cmp = key_compare_it;
- parms.pos = *isam_p;
- parms.is = zi->reg->isamb;
- return rset_create (rset_kind_isamb, &parms);
- }
- */
-#if 1
else if (no <10000 ) /* FIXME - hardcoded number */
{
RSET r;
RSET *rsets=xmalloc(no*sizeof(RSET)); /* use nmem! */
int i;
for (i=0;i<no;i++)
- rsets[i]=rsisamb_create(NULL, /* */
- sizeof(struct it_key), key_compare_it,
+ rsets[i]=rsisamb_create(rset_nmem, kctrl,
zi->reg->isamb, isam_p[i] );
- r=rsmultior_create( rset_nmem, /* FIXME - use some nmem */
- sizeof(struct it_key), key_compare_it,
- no, rsets);
+ r=rsmultior_create( rset_nmem, kctrl, no, rsets);
xfree(rsets);
- return r;
- /*
- rset_multior_parms m_parms;
- rset_isamb_parms b_parms;
- int i;
- m_parms.key_size = sizeof(struct it_key);
- m_parms.cmp = key_compare_it;
- m_parms.no_rsets=no;
- m_parms.rsets=xmalloc(sizeof(*m_parms.rsets)*no);
- b_parms.key_size = sizeof(struct it_key);
- b_parms.cmp = key_compare_it;
- b_parms.is = zi->reg->isamb;
- for (i=0;i<no;i++)
- {
- b_parms.pos = isam_p[i];
- m_parms.rsets[i]=rset_create (rset_kind_isamb, &b_parms);
- }
- return rset_create (rset_kind_multior, &m_parms);
- */
- } /* <10000 - rs_multior */
-#endif
+ }
qsort (isam_p, no, sizeof(*isam_p), isamc_trunc_cmp);
}
else
{
logf (LOG_WARN, "Unknown isam set in rset_trunc");
- return rsnull_create (NULL); /* FIXME - nmem */
+ return rsnull_create (rset_nmem, kctrl);
}
return rset_trunc_r (zi, term, length, flags, isam_p, 0, no, 100,
- preserve_position, term_type, rset_nmem);
+ preserve_position, term_type, rset_nmem,kctrl);
}
-/* $Id: zrpn.c,v 1.148 2004-08-31 14:43:41 heikki Exp $
+/* $Id: zrpn.c,v 1.149 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <zebra_xpath.h>
#include <charmap.h>
-#include <rstemp.h>
-#include <rsnull.h>
-#include <rsbool.h>
-#include <rsmultior.h>
-#include <rsbetween.h>
-#include <rsprox.h>
+#include <rset.h>
+
+
+static const struct key_control it_ctrl={
+ sizeof(struct it_key),
+ key_compare_it,
+ key_logdump_txt, /* FIXME - clean up these functions */
+ key_get_seq,
+};
+
+const struct key_control *key_it_ctrl=&it_ctrl;
struct rpn_char_map_info {
ZebraMaps zm;
return rset_trunc (zh, grep_info->isam_p_buf,
grep_info->isam_p_indx, term_dst,
strlen(term_dst), rank_type, 1 /* preserve pos */,
- zapt->term->which, rset_nmem);
+ zapt->term->which, rset_nmem,key_it_ctrl);
}
}
grep_info_delete (&grep_info);
if (rset_no == 0)
- return rsnull_create (NULL); /* FIXME - Use a proper nmem */
+ return rsnull_create (rset_nmem,key_it_ctrl);
else if (rset_no == 1)
return (rset[0]);
else
- result = rsprox_create( NULL, /* FIXME - use a proper nmem */
- sizeof(struct it_key), key_compare_it, key_get_seq,
+ result = rsprox_create( rset_nmem, key_it_ctrl,
rset_no, rset,
1 /* ordered */, 0 /* exclusion */,
3 /* relation */, 1 /* distance */);
}
grep_info_delete (&grep_info);
if (rset_no == 0)
- return rsnull_create (rset_nmem);
- return rsmultior_create(rset_nmem,
- sizeof(struct it_key),
- key_compare_it,
+ return rsnull_create (rset_nmem,key_it_ctrl);
+ return rsmultior_create(rset_nmem, key_it_ctrl,
rset_no, rset);
-
-#if 0
- /* The old code, kept for reference. May be deleted soon */
- result = rset[0];
- for (i = 1; i<rset_no; i++)
- {
- rset_bool_parms bool_parms;
- bool_parms.rset_l = result;
- bool_parms.rset_r = rset[i];
- bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare_it;
- bool_parms.log_item = key_logdump_txt;
- result = rset_create (rset_kind_or, &bool_parms);
- }
- return result;
-#endif
}
static RSET rpn_search_APT_and_list (ZebraHandle zh,
}
grep_info_delete (&grep_info);
if (rset_no == 0)
- return rsnull_create (rset_nmem);
+ return rsnull_create (rset_nmem,key_it_ctrl);
result = rset[0];
/* FIXME - Use a proper rsmultiand */
for (i = 1; i<rset_no; i++)
- {
- /*
- rset_bool_parms bool_parms;
- bool_parms.rset_l = result;
- bool_parms.rset_r = rset[i];
- bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare_it;
- bool_parms.log_item = key_logdump_txt;
- result = rset_create (rset_kind_and, &bool_parms);
- */
- result= rsbool_create_and(NULL, /* FIXME - use a proper nmem */
- sizeof(struct it_key), key_compare_it,
- result, rset[i], key_logdump_txt );
- }
+ result= rsbool_create_and(rset_nmem,key_it_ctrl,
+ result, rset[i] );
return result;
}
grep_info.isam_p_indx, term_dst,
strlen(term_dst), rank_type,
0 /* preserve position */,
- zapt->term->which, rset_nmem);
+ zapt->term->which, rset_nmem, key_it_ctrl);
assert (rset[rset_no]);
if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
break;
}
grep_info_delete (&grep_info);
if (rset_no == 0)
- return rsnull_create (rset_nmem);
+ return rsnull_create (rset_nmem,key_it_ctrl);
result = rset[0];
for (i = 1; i<rset_no; i++)
{
- /*
- rset_bool_parms bool_parms;
- bool_parms.rset_l = result;
- bool_parms.rset_r = rset[i];
- bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare_it;
- bool_parms.log_item = key_logdump_txt;
- result = rset_create (rset_kind_and, &bool_parms);
- */
/* FIXME - Use a proper multi-and */
- result= rsbool_create_and(NULL, /* FIXME - use a proper nmem */
- sizeof(struct it_key), key_compare_it,
- result, rset[i], key_logdump_txt );
+ result= rsbool_create_and(rset_nmem,key_it_ctrl,
+ result, rset[i] );
}
return result;
}
parms.temp_path = res_get (zh->res, "setTmpDir");
result = rset_create (rset_kind_temp, &parms);
*/
- result = rstemp_create( rset_nmem,
- sizeof (struct it_key), key_compare_it,
+ result = rstemp_create( rset_nmem,key_it_ctrl,
res_get (zh->res, "setTmpDir") );
rsfd = rset_open (result, RSETF_WRITE);
sks->which = Z_SortKeySpec_null;
sks->u.null = odr_nullval ();
sort_sequence->specs[i] = sks;
- return rsnull_create (NULL); /* FIXME - Use a proper nmem */
+ return rsnull_create (NULL,key_it_ctrl);
+ /* FIXME - nmem?? */
}
const char *flags = "void";
if (grep_info_prepare (zh, 0 /* zapt */, &grep_info, '0', stream))
- return rsnull_create (rset_nmem);
+ return rsnull_create (rset_nmem,key_it_ctrl);
if (ord < 0)
- return rsnull_create (rset_nmem);
+ return rsnull_create (rset_nmem,key_it_ctrl);
if (prefix_len)
term_dict[prefix_len++] = '|';
else
grep_info.isam_p_indx);
rset = rset_trunc (zh, grep_info.isam_p_buf,
grep_info.isam_p_indx, term, strlen(term),
- flags, 1, term_type,rset_nmem);
+ flags, 1, term_type,rset_nmem,key_it_ctrl);
grep_info_delete (&grep_info);
return rset;
}
parms.printer = key_print_it;
rset = rset_create (rset_kind_between, &parms);
*/
- rset=rsbetween_create( rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset_start_tag, rset, rset_end_tag, rset_attr,
- key_print_it );
+ rset=rsbetween_create( rset_nmem,key_it_ctrl,
+ rset_start_tag, rset, rset_end_tag, rset_attr);
}
first_path = 0;
}
switch (zop->which)
{
case Z_Operator_and:
- r = rsbool_create_and( rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset_l, rset_r, key_logdump_txt );
+ r = rsbool_create_and(rset_nmem,key_it_ctrl, rset_l,rset_r );
break;
case Z_Operator_or:
- r = rsbool_create_or( rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset_l, rset_r, key_logdump_txt );
+ r = rsbool_create_or(rset_nmem,key_it_ctrl, rset_l,rset_r );
break;
case Z_Operator_and_not:
- r = rsbool_create_not( rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset_l, rset_r, key_logdump_txt );
+ r = rsbool_create_not(rset_nmem,key_it_ctrl, rset_l,rset_r );
break;
case Z_Operator_prox:
if (zop->u.prox->which != Z_ProximityOperator_known)
twosets[0] = rset_l;
twosets[1] = rset_r;
- r=rsprox_create(rset_nmem,
- sizeof(struct it_key), key_compare_it,
- key_get_seq,
+ r=rsprox_create(rset_nmem,key_it_ctrl,
2, twosets,
*zop->u.prox->ordered,
(!zop->u.prox->exclusion ?
0 : *zop->u.prox->exclusion),
*zop->u.prox->relationType,
*zop->u.prox->distance );
- /*
- parms.rset = twosets;
- parms.rset_no = 2;
- parms.ordered = *zop->u.prox->ordered;
- parms.exclusion = (!zop->u.prox->exclusion ? 0 :
- *zop->u.prox->exclusion);
- parms.relation = *zop->u.prox->relationType;
- parms.distance = *zop->u.prox->distance;
- parms.key_size = sizeof(struct it_key);
- parms.cmp = key_compare_it;
- parms.getseq = key_get_seq;
- parms.log_item = key_logdump_txt;
- r = rset_create(rset_kind_prox, &parms);
- */
}
break;
default:
r = resultSetRef (zh, zs->u.simple->u.resultSetId);
if (!r)
{
- r = rsnull_create (rset_nmem);
+ r = rsnull_create (rset_nmem,key_it_ctrl);
zh->errCode = 30;
zh->errString =
nmem_strdup (stream, zs->u.simple->u.resultSetId);
&glist[i+before].term, mterm);
rset = rset_trunc (zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
glist[i+before].term, strlen(glist[i+before].term),
- NULL, 0, zapt->term->which, rset_nmem);
+ NULL, 0, zapt->term->which, rset_nmem, key_it_ctrl);
ptr[j0]++;
for (j = j0+1; j<ord_no; j++)
rset_trunc (zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
glist[i+before].term,
strlen(glist[i+before].term), NULL, 0,
- zapt->term->which,rset_nmem);
- rset = rsbool_create_or(rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset, rset2, key_logdump_txt);
+ zapt->term->which,rset_nmem,key_it_ctrl);
+ rset = rsbool_create_or(rset_nmem,key_it_ctrl,
+ rset, rset2);
+ /* FIXME - Use a proper multi-or */
ptr[j]++;
}
}
if (limit_set)
- rset = rsbool_create_and(rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset, rset_dup(limit_set),
- key_logdump_txt);
+ rset = rsbool_create_and(rset_nmem,key_it_ctrl,
+ rset, rset_dup(limit_set));
count_set (rset, &glist[i+before].occurrences);
rset_delete (rset);
}
rset = rset_trunc
(zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
glist[before-1-i].term, strlen(glist[before-1-i].term),
- NULL, 0, zapt->term->which,rset_nmem);
+ NULL, 0, zapt->term->which,rset_nmem,key_it_ctrl);
ptr[j0]++;
&scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
glist[before-1-i].term,
strlen(glist[before-1-i].term), NULL, 0,
- zapt->term->which, rset_nmem);
- rset = rsbool_create_and(rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset, rset2,
- key_logdump_txt);
+ zapt->term->which, rset_nmem,key_it_ctrl);
+ rset = rsbool_create_and(rset_nmem,key_it_ctrl,
+ rset, rset2);
+ /* FIXME - multi-and ?? */
ptr[j]++;
}
}
if (limit_set)
- rset = rsbool_create_and(rset_nmem,
- sizeof(struct it_key), key_compare_it,
- rset, rset_dup(limit_set),
- key_logdump_txt);
+ rset = rsbool_create_and(rset_nmem,key_it_ctrl,
+ rset, rset_dup(limit_set));
count_set (rset, &glist[before-1-i].occurrences);
rset_delete (rset);
}
-/* $Id: zsets.c,v 1.59 2004-08-31 10:43:35 heikki Exp $
+/* $Id: zsets.c,v 1.60 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#endif
#include "index.h"
-#include <rstemp.h>
+#include <rset.h>
#define SORT_IDX_ENTRYSIZE 64
#define ZSET_SORT_MAX_LEVEL 3
-/* $Id: rsbetween.c,v 1.23 2004-08-31 10:43:36 heikki Exp $
+/* $Id: rsbetween.c,v 1.24 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <assert.h>
#include <zebrautl.h>
-#include <rsbetween.h>
+#include <rset.h>
#define RSBETWEEN_DEBUG 0
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(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf);
+static int r_forward_between(RSFD rfd, void *buf, const void *untilbuf);
static int r_read_between (RSFD rfd, void *buf);
static int r_write_between (RSFD rfd, const void *buf);
static void r_pos_between (RSFD rfd, double *current, double *total);
r_open_between,
r_close_between,
r_rewind_between,
- r_forward_between, /* rset_default_forward, */
+ r_forward_between,
r_pos_between,
r_read_between,
r_write_between,
const struct rset_control *rset_kind_between = &control;
struct rset_between_info {
- int key_size;
- RSET rset_l;
- RSET rset_m;
- RSET rset_r;
- RSET rset_attr;
- int (*cmp)(const void *p1, const void *p2);
- char *(*printer)(const void *p1, char *buf);
+ RSET rset_l; /* left arg, start tag */
+ RSET rset_m; /* the thing itself */
+ RSET rset_r; /* right arg, end tag */
+ RSET rset_attr; /* attributes , optional */
};
struct rset_between_rfd {
void *buf_m;
void *buf_r;
void *buf_attr;
- int level;
- struct rset_between_rfd *next;
- struct rset_between_info *info;
+ int level; /* counting start/end tags */
zint hits;
};
}
#endif
-RSET rsbetween_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr,
- char *(*printer)(const void *p1, char *buf) )
+RSET rsbetween_create( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr)
{
- RSET rnew=rset_create_base(&control, nmem);
- struct rset_between_info *info;
- info = (struct rset_between_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
+ struct rset_between_info *info=
+ (struct rset_between_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->rset_l = rset_l;
info->rset_m = rset_m;
info->rset_r = rset_r;
info->rset_attr = rset_attr;
- info->cmp = cmp;
- info->printer = printer;
-
rnew->priv=info;
return rnew;
}
else {
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));
+ p->buf_l = nmem_malloc(ct->nmem, (ct->keycontrol->key_size));
+ p->buf_m = nmem_malloc(ct->nmem, (ct->keycontrol->key_size));
+ p->buf_r = nmem_malloc(ct->nmem, (ct->keycontrol->key_size));
+ p->buf_attr = nmem_malloc(ct->nmem, (ct->keycontrol->key_size));
}
p->rfd_l = rset_open (info->rset_l, RSETF_READ);
-static int r_forward_between(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf)
+static int r_forward_between(RSFD rfd, void *buf, const void *untilbuf)
{
- 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
/* 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(p->rfd_m, p->buf_m,
- info->cmp,untilbuf);
+ p->more_m=rset_forward(p->rfd_m, p->buf_m,untilbuf);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward M", 0,0);
#endif
{
struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
+ const struct key_control *kctrl=rfd->rset->keycontrol;
int cmp_l=0;
int cmp_r=0;
int attr_match = 0;
/* forward L until past m, count levels, note rec boundaries */
if (p->more_l)
- cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
+ cmp_l= (*kctrl->cmp)(p->buf_l, p->buf_m);
else
{
p->level = 0;
attr_match = 0;
while (p->more_attr)
{
- cmp_attr = (*info->cmp)(p->buf_attr, p->buf_l);
+ cmp_attr = (*kctrl->cmp)(p->buf_attr, p->buf_l);
if (cmp_attr == 0)
{
attr_match = 1;
else if (cmp_attr==-2)
{
p->more_attr = rset_forward( p->rfd_attr,
- p->buf_attr, info->cmp, p->buf_l);
+ p->buf_attr, p->buf_l);
#if RSBETWEEN_DEBUG
- logf(LOG_DEBUG, "btw: after frowarding attr m=%d",p->more_attr);
+ logf(LOG_DEBUG, "btw: after frowarding attr m=%d",
+ p->more_attr);
#endif
}
} /* while more_attr */
{
if (p->more_l)
{
- p->more_l=rset_forward(p->rfd_l,
- p->buf_l, info->cmp, p->buf_m);
+ p->more_l=rset_forward(p->rfd_l, p->buf_l, p->buf_m);
if (p->more_l)
- cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
+ cmp_l= (*kctrl->cmp)(p->buf_l, p->buf_m);
else
cmp_l=2;
#if RSBETWEEN_DEBUG
#endif
if (p->more_l)
{
- cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
+ cmp_l= (*kctrl->cmp)(p->buf_l, p->buf_m);
}
else
cmp_l=2;
log2( p, "Before moving R", cmp_l, cmp_r);
#endif
if (p->more_r)
- cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
+ cmp_r= (*kctrl->cmp)(p->buf_r, p->buf_m);
else
cmp_r=2;
#if RSBETWEEN_DEBUG
#if NEWCODE
if (cmp_r==-2)
{
- p->more_r=rset_forward(p->rfd_r,
- p->buf_r, info->cmp, p->buf_m);
+ p->more_r=rset_forward(p->rfd_r, p->buf_r, p->buf_m);
} else
{
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);
+ cmp_r= (*kctrl->cmp)(p->buf_r, p->buf_m);
#else
p->more_r = rset_read (p->rfd_r, p->buf_r);
- cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
+ cmp_r= (*kctrl->cmp)(p->buf_r, p->buf_m);
#endif
}
else
if ( attr_match && p->level > 0) /* within a tag pair (or deeper) */
{
- memcpy (buf, p->buf_m, info->key_size);
+ memcpy (buf, p->buf_m, kctrl->key_size);
#if RSBETWEEN_DEBUG
log2( p, "Returning a hit (and forwarding m)", cmp_l, cmp_r);
#endif
if (cmp_l == 2)
{
p->level = 0;
- p->more_m=rset_forward(p->rfd_m,
- p->buf_m, info->cmp, p->buf_l);
+ p->more_m=rset_forward(p->rfd_m, p->buf_m, p->buf_l);
} else
{
p->more_m = rset_read (p->rfd_m, p->buf_m);
-/* $Id: rsbool.c,v 1.45 2004-08-31 10:43:39 heikki Exp $
+/* $Id: rsbool.c,v 1.46 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <zebrautl.h>
#include <rset.h>
-#include <rsbool.h>
#ifndef RSET_DEBUG
#define RSET_DEBUG 0
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf);
+static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
static int r_read_and (RSFD rfd, void *buf);
static int r_read_or (RSFD rfd, void *buf);
const struct rset_control *rset_kind_and = &control_and;
-const struct rset_control *rset_kind_or = &control_or;
+const struct rset_control *rset_kind_or = &control_or;
const struct rset_control *rset_kind_not = &control_not;
struct rset_bool_info {
- int key_size;
RSET rset_l;
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 {
void *buf_l;
void *buf_r;
int tail;
- struct rset_bool_rfd *next;
- struct rset_bool_info *info;
};
static RSET rsbool_create_base( const struct rset_control *ctrl,
- NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- RSET rset_l, RSET rset_r,
- void (*log_item)(int logmask, const void *p, const char *txt) )
+ NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r)
{
- RSET rnew=rset_create_base(ctrl, nmem);
+ RSET rnew=rset_create_base(ctrl, nmem, kcontrol);
struct rset_bool_info *info;
info = (struct rset_bool_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
info->rset_l = rset_l;
info->rset_r = rset_r;
- info->cmp = cmp;
- info->log_item = log_item;
-
rnew->priv=info;
return rnew;
}
-RSET rsbool_create_and( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- RSET rset_l, RSET rset_r,
- void (*log_item)(int logmask, const void *p, const char *txt) )
+RSET rsbool_create_and( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r)
{
- return rsbool_create_base(rset_kind_and, nmem, key_size, cmp,
- rset_l, rset_r, log_item);
+ return rsbool_create_base(rset_kind_and, nmem, kcontrol,
+ rset_l, rset_r);
}
-RSET rsbool_create_or( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- RSET rset_l, RSET rset_r,
- void (*log_item)(int logmask, const void *p, const char *txt) )
+RSET rsbool_create_or( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r)
{
- return rsbool_create_base(rset_kind_or, nmem, key_size, cmp,
- rset_l, rset_r, log_item);
+ return rsbool_create_base(rset_kind_or, nmem, kcontrol,
+ rset_l, rset_r);
}
-RSET rsbool_create_not( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- RSET rset_l, RSET rset_r,
- void (*log_item)(int logmask, const void *p, const char *txt) )
+RSET rsbool_create_not( NMEM nmem, const struct key_control *kcontrol,
+ RSET rset_l, RSET rset_r)
{
- return rsbool_create_base(rset_kind_not, nmem, key_size, cmp,
- rset_l, rset_r, log_item);
+ return rsbool_create_base(rset_kind_not, nmem, kcontrol,
+ rset_l, rset_r);
}
static void r_delete (RSET ct)
else {
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);
+ p->buf_l = nmem_malloc(ct->nmem, ct->keycontrol->key_size);
+ p->buf_r = nmem_malloc(ct->nmem, ct->keycontrol->key_size);
}
logf(LOG_DEBUG,"rsbool (%s) open [%p]", ct->control->desc, rfd);
}
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_info*)(rfd->rset->priv);
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
- int rc;
-
- if ( p->more_l && ((cmpfunc)(untilbuf,p->buf_l)==2) )
- p->more_l = rset_forward(p->rfd_l, p->buf_l,
- info->cmp, untilbuf);
- if ( p->more_r && ((cmpfunc)(untilbuf,p->buf_r)==2))
- p->more_r = rset_forward(p->rfd_r, p->buf_r,
- info->cmp, untilbuf);
+ const struct key_control *kctrl=rfd->rset->keycontrol;
+
+ if ( p->more_l && ((kctrl->cmp)(untilbuf,p->buf_l)==2) )
+ p->more_l = rset_forward(p->rfd_l, p->buf_l, untilbuf);
+ if ( p->more_r && ((kctrl->cmp)(untilbuf,p->buf_r)==2))
+ p->more_r = rset_forward(p->rfd_r, p->buf_r, untilbuf);
p->tail=0;
- rc = rset_read(rfd,buf);
- return rc;
+ return rset_read(rfd,buf);
}
static int r_read_and (RSFD rfd, void *buf)
{
- struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
+ const struct key_control *kctrl=rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
int cmp;
if (p->more_l && p->more_r)
- cmp = (*info->cmp)(p->buf_l, p->buf_r);
+ cmp = (*kctrl->cmp)(p->buf_l, p->buf_r);
else if (p->more_l)
cmp = -2;
else
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] looping: m=%d/%d c=%d t=%d",
rfd, p->more_l, p->more_r, cmp, p->tail);
- (*info->log_item)(LOG_DEBUG, p->buf_l, "left ");
- (*info->log_item)(LOG_DEBUG, p->buf_r, "right ");
+ (*kctrl->log_item)(LOG_DEBUG, p->buf_l, "left ");
+ (*kctrl->log_item)(LOG_DEBUG, p->buf_r, "right ");
#endif
if (!cmp)
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
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);
+ memcpy (buf, p->buf_r, kctrl->key_size);
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",
rfd, p->more_l, p->more_r, cmp);
key_logdump(LOG_DEBUG,buf);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
}
else if (cmp == -1)
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
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",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
}
else if (cmp > 1) /* cmp == 2 */
{
-#define OLDCODE 0
-#if OLDCODE
- memcpy (buf, p->buf_r, info->key_size);
-
- 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)
- p->tail = 0;
-#if RSET_DEBUG
- logf (LOG_DEBUG, "r_read_and returning C m=%d/%d c=%d",
- p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
-#endif
- p->hits++;
- return 1;
- }
-#else
-
if (p->tail)
{
- memcpy (buf, p->buf_r, info->key_size);
+ memcpy (buf, p->buf_r, kctrl->key_size);
p->more_r = rset_read (p->rfd_r, p->buf_r);
- if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
+ if (!p->more_r || (*kctrl->cmp)(p->buf_r, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R tail m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
else
{
#if RSET_DEBUG
- logf (LOG_DEBUG, "r_read_and [%p] about to forward R m=%d/%d c=%d",
+ logf (LOG_DEBUG, "r_read_and [%p] about to forward R "
+ "m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_r = rset_forward( p->rfd_r,
- p->buf_r, (info->cmp), p->buf_l);
+ p->more_r = rset_forward( p->rfd_r, p->buf_r, p->buf_l);
else
return 0; /* no point in reading further */
}
-#endif
}
else /* cmp == -2 */
{
-#if OLDCODE
- memcpy (buf, p->buf_l, info->key_size);
- 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)
- p->tail = 0;
-#if RSET_DEBUG
- logf (LOG_DEBUG, "r_read_and [%p] returning R tail m=%d/%d c=%d",
- rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
-#endif
- p->hits++;
- return 1;
- }
-#else
if (p->tail)
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
p->more_l = rset_read (p->rfd_l, p->buf_l);
- if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
+ if (!p->more_l || (*kctrl->cmp)(p->buf_l, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning L tail m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
else
{
#if RSET_DEBUG
- logf (LOG_DEBUG, "r_read_and [%p] about to forward L m=%d/%d c=%d",
+ logf (LOG_DEBUG, "r_read_and [%p] about to forward L "
+ "m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_l = rset_forward(p->rfd_l,
- p->buf_l, (info->cmp), p->buf_r);
+ p->more_l = rset_forward(p->rfd_l, p->buf_l, p->buf_r);
else
return 0; /* no point in reading further */
}
-#endif
}
}
#if RSET_DEBUG
static int r_read_or (RSFD rfd, void *buf)
{
- struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
+ const struct key_control *kctrl=rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
int cmp;
if (p->more_l && p->more_r)
- cmp = (*info->cmp)(p->buf_l, p->buf_r);
+ cmp = (*kctrl->cmp)(p->buf_l, p->buf_r);
else if (p->more_r)
cmp = 2;
else
cmp = -2;
if (!cmp)
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
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);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
}
else if (cmp > 0)
{
- memcpy (buf, p->buf_r, info->key_size);
+ memcpy (buf, p->buf_r, kctrl->key_size);
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);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
}
else
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
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);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*kctrl->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
static int r_read_not (RSFD rfd, void *buf)
{
- struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
+ const struct key_control *kctrl=rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
int cmp;
if (p->more_l && p->more_r)
- cmp = (*info->cmp)(p->buf_l, p->buf_r);
+ cmp = (*kctrl->cmp)(p->buf_l, p->buf_r);
else if (p->more_r)
cmp = 2;
else
cmp = -2;
if (cmp < -1)
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
p->more_l = rset_read (p->rfd_l, p->buf_l);
p->hits++;
return 1;
}
else if (cmp > 1)
- {
- p->more_r = rset_forward( p->rfd_r,
- p->buf_r, (info->cmp), p->buf_l);
- }
+ p->more_r = rset_forward( p->rfd_r, p->buf_r, p->buf_l);
else
{
- memcpy (buf, p->buf_l, info->key_size);
+ memcpy (buf, p->buf_l, kctrl->key_size);
do
{
p->more_l = rset_read (p->rfd_l, p->buf_l);
if (!p->more_l)
break;
- cmp = (*info->cmp)(p->buf_l, buf);
+ cmp = (*kctrl->cmp)(p->buf_l, buf);
} while (cmp >= -1 && cmp <= 1);
do
{
p->more_r = rset_read (p->rfd_r, p->buf_r);
if (!p->more_r)
break;
- cmp = (*info->cmp)(p->buf_r, buf);
+ cmp = (*kctrl->cmp)(p->buf_r, buf);
} while (cmp >= -1 && cmp <= 1);
}
}
-/* $Id: rset.c,v 1.30 2004-08-31 14:43:42 heikki Exp $
+/* $Id: rset.c,v 1.31 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
}
-RSET rset_create_base(const struct rset_control *sel, NMEM nmem)
+RSET rset_create_base(const struct rset_control *sel,
+ NMEM nmem, const struct key_control *kcontrol)
/* FIXME - Add keysize and cmp function */
/* FIXME - Add a general key-func block for cmp, dump, etc */
{
rnew->count = 1;
rnew->priv = 0;
rnew->free_list=NULL;
+ rnew->keycontrol=kcontrol;
return rnew;
}
#endif
int rset_default_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
int more=1;
logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
more=rset_read(rfd, buf);
if (more)
- cmp=(*cmpfunc)(untilbuf,buf);
+ cmp=(rfd->rset->keycontrol->cmp)(untilbuf,buf);
/* if (more)
key_logdump(LOG_DEBUG,buf); */
}
-/* $Id: rsisamb.c,v 1.20 2004-08-31 14:43:42 heikki Exp $
+/* $Id: rsisamb.c,v 1.21 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <stdio.h>
#include <assert.h>
#include <zebrautl.h>
-#include <rsisamb.h>
+#include <rset.h>
#include <string.h>
-#include <../index/index.h> /* for log_keydump. Debugging only */
#ifndef RSET_DEBUG
#define RSET_DEBUG 0
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf);
+static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
struct rset_isamb_info {
ISAMB is;
ISAMB_P pos;
- int key_size;
- int (*cmp)(const void *p1, const void *p2);
};
-RSET rsisamb_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
+RSET rsisamb_create( NMEM nmem, const struct key_control *kcontrol,
ISAMB is, ISAMB_P pos)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
struct rset_isamb_info *info;
info = (struct rset_isamb_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
- info->cmp = cmp;
info->is=is;
info->pos=pos;
rnew->priv=info;
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);
+ ptinfo = (struct rset_pp_info *)nmem_malloc(ct->nmem,sizeof(*ptinfo));
+ ptinfo->buf = nmem_malloc (ct->nmem,ct->keycontrol->key_size);
rfd->priv=ptinfo;
}
ptinfo->pt = isamb_pp_open (info->is, info->pos);
abort ();
}
-static int r_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf)
+static int r_forward(RSFD rfd, void *buf, const void *untilbuf)
{
struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
return isamb_pp_forward(pinfo->pt, buf, untilbuf);
-/* $Id: rsisamc.c,v 1.23 2004-08-31 10:43:39 heikki Exp $
+/* $Id: rsisamc.c,v 1.24 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <assert.h>
#include <string.h>
#include <zebrautl.h>
-#include <rsisamc.h>
+#include <rset.h>
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
struct rset_pp_info {
ISAMC_PP pt;
- struct rset_pp_info *next;
- struct rset_isamc_info *info;
void *buf;
};
struct rset_isamc_info {
ISAMC is;
ISAMC_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 rsisamc_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- ISAMC is, ISAMC_P pos)
+RSET rsisamc_create( NMEM nmem, const struct key_control *kcontrol,
+ ISAMC is, ISAMC_P pos)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
struct rset_isamc_info *info;
info = (struct rset_isamc_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
- info->cmp = cmp;
- info->ispt_list = NULL;
- info->free_list = NULL;
info->is=is;
info->pos=pos;
rnew->priv=info;
static void r_delete (RSET ct)
{
- struct rset_isamc_info *info = (struct rset_isamc_info *) ct->priv;
-
logf (LOG_DEBUG, "rsisamc_delete");
- assert (info->ispt_list == NULL);
}
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;
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->buf = nmem_malloc (ct->nmem,ct->keycontrol->key_size);
}
return rfd;
}
*current=-1; /* sorry, not implemented yet */
*total=-1;
}
+
-/* $Id: rsisams.c,v 1.11 2004-08-31 10:43:39 heikki Exp $
+/* $Id: rsisams.c,v 1.12 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <stdio.h>
#include <assert.h>
#include <zebrautl.h>
-#include <rsisams.h>
+#include <rset.h>
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
};
-RSET rsisams_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
+RSET rsisams_create( NMEM nmem, const struct key_control *kcontrol,
ISAMS is, ISAMS_P pos)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
struct rset_isams_info *info;
info = (struct rset_isams_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- assert(key_size); /* FIXME - these belong to the general rset */
- assert(cmp);
+ rnew->priv=info;
info->is=is;
info->pos=pos;
- rnew->priv=info;
return rnew;
}
-/* $Id: rsmultior.c,v 1.8 2004-08-31 10:43:39 heikki Exp $
+/* $Id: rsmultior.c,v 1.9 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <zebrautl.h>
#include <isamc.h>
-#include <rsmultior.h>
+#include <rset.h>
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const 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);
struct heap {
int heapnum;
int heapmax;
- int keysize;
- int (*cmp)(const void *p1, const void *p2);
+ const struct key_control *kctrl;
struct heap_item **heap; /* ptrs to the rfd */
};
typedef struct heap *HEAP;
struct rset_multior_info {
- int key_size;
- int no_rec;
- int (*cmp)(const void *p1, const void *p2);
int no_rsets;
RSET *rsets;
};
struct heap_item *items; /* we alloc and free them here */
HEAP h;
zint hits; /* returned so far */
- char *prevvalue; /* to see if we are in another record */
- /* FIXME - is this really needed? */
};
#if 0
static int heap_cmp(HEAP h, int x, int y)
{
- return (*h->cmp)(h->heap[x]->buf,h->heap[y]->buf);
+ return (*h->kctrl->cmp)(h->heap[x]->buf,h->heap[y]->buf);
}
static int heap_empty(HEAP h)
static
-HEAP heap_create (NMEM nmem, int size, int key_size,
- int (*cmp)(const void *p1, const void *p2))
+HEAP heap_create (NMEM nmem, int size, const struct key_control *kctrl)
{
HEAP h = (HEAP) nmem_malloc (nmem, sizeof(*h));
++size; /* heap array starts at 1 */
h->heapnum = 0;
h->heapmax = size;
- h->keysize = key_size;
- h->cmp = cmp;
- h->heap = (struct heap_item**) nmem_malloc(nmem,(size)*sizeof(*h->heap));
+ h->kctrl=kctrl;
+ h->heap = (struct heap_item**) nmem_malloc(nmem,size*sizeof(*h->heap));
h->heap[0]=0; /* not used */
return h;
}
}
-RSET rsmultior_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
+RSET rsmultior_create( NMEM nmem, const struct key_control *kcontrol,
int no_rsets, RSET* rsets)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem,kcontrol);
struct rset_multior_info *info;
info = (struct rset_multior_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
- info->cmp = cmp;
info->no_rsets=no_rsets;
info->rsets=(RSET*)nmem_malloc(rnew->nmem, no_rsets*sizeof(*rsets));
memcpy(info->rsets,rsets,no_rsets*sizeof(*rsets));
RSFD rfd;
struct rset_multior_rfd *p;
struct rset_multior_info *info = (struct rset_multior_info *) ct->priv;
+ const struct key_control *kctrl = ct->keycontrol;
int i;
if (flag & RSETF_WRITE)
else {
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);
+ p->h = heap_create( ct->nmem, info->no_rsets, kctrl);
p->items=(struct heap_item *) nmem_malloc(ct->nmem,
info->no_rsets*sizeof(*p->items));
for (i=0; i<info->no_rsets; i++){
p->items[i].rset=info->rsets[i];
- p->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
+ p->items[i].buf=nmem_malloc(ct->nmem,kctrl->key_size);
}
}
p->flag = flag;
- p->prevvalue=0;
p->hits=0;
for (i=0; i<info->no_rsets; i++){
p->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
}
-static int r_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf)
+static int r_forward(RSFD rfd, void *buf, const void *untilbuf)
{
- struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
- struct rset_multior_rfd *mrfd=(struct rset_multior_rfd *)(rfd->priv);
+ struct rset_multior_rfd *mrfd=rfd->priv;
+ const struct key_control *kctrl=rfd->rset->keycontrol;
struct heap_item it;
int rdres;
if (heap_empty(mrfd->h))
return 0;
- if (cmpfunc)
- assert(cmpfunc==info->cmp);
it = *(mrfd->h->heap[1]);
- memcpy(buf,it.buf, info->key_size);
+ memcpy(buf,it.buf, kctrl->key_size);
(mrfd->hits)++;
if (untilbuf)
- rdres=rset_forward(it.fd, it.buf, cmpfunc,untilbuf);
+ rdres=rset_forward(it.fd, it.buf, untilbuf);
else
rdres=rset_read(it.fd, it.buf);
if ( rdres )
static int r_read (RSFD rfd, void *buf)
{
- return r_forward(rfd, buf,0,0);
+ return r_forward(rfd, buf,0);
}
static void r_pos (RSFD rfd, double *current, double *total)
-/* $Id: rsnull.c,v 1.24 2004-08-31 10:43:39 heikki Exp $
+/* $Id: rsnull.c,v 1.25 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <stdio.h>
#include <assert.h>
#include <zebrautl.h>
-#include <rsnull.h>
+#include <rset.h>
static RSFD r_open (RSET ct, int flag);
const struct rset_control *rset_kind_null = &control;
-RSET rsnull_create(NMEM nmem )
+RSET rsnull_create(NMEM nmem, const struct key_control *kcontrol )
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
rnew->priv=NULL;
return rnew;
}
-/* $Id: rsprox.c,v 1.13 2004-08-31 10:43:40 heikki Exp $
+/* $Id: rsprox.c,v 1.14 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <assert.h>
#include <zebrautl.h>
-#include <rsprox.h>
+#include <rset.h>
#ifndef RSET_DEBUG
#define RSET_DEBUG 0
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf);
+static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
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);
const struct rset_control *rset_kind_prox = &control;
struct rset_prox_info {
-/* struct rset_prox_parms p; */
- RSET *rset;
- int rset_no;
+ RSET *rset; /* array of 'child' rsets */
+ int rset_no; /* how many of them */
int ordered;
int exclusion;
int relation;
int distance;
- int key_size;
- int (*cmp)(const void *p1, const void *p2);
- int (*getseq)(const void *p);
};
struct rset_prox_rfd {
};
-RSET rsprox_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
- int (*getseq)(const void *p),
+RSET rsprox_create( NMEM nmem, const struct key_control *kcontrol,
int rset_no, RSET *rset,
int ordered, int exclusion,
int relation, int distance)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
struct rset_prox_info *info;
info = (struct rset_prox_info *) nmem_malloc(rnew->nmem,sizeof(*info));
- info->key_size = key_size;
- info->cmp = cmp;
- info->getseq=getseq; /* FIXME - what about multi-level stuff ?? */
info->rset = nmem_malloc(rnew->nmem,rset_no * sizeof(*info->rset));
memcpy(info->rset, rset,
rset_no * sizeof(*info->rset));
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++)
- p->buf[i] = nmem_malloc(ct->nmem,info->key_size);
+ p->buf[i] = nmem_malloc(ct->nmem,ct->keycontrol->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);
+ logf(LOG_DEBUG,"rsprox (%s) open [%p] n=%d",
+ ct->control->desc, rfd, info->rset_no);
for (i = 0; i < info->rset_no; i++) {
p->rfd[i] = rset_open (info->rset[i], RSETF_READ);
p->hits=0;
}
-static int r_forward (RSFD rfd, void *buf,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf)
+static int r_forward (RSFD rfd, void *buf, const void *untilbuf)
{
struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
+ const struct key_control *kctrl=rfd->rset->keycontrol;
int cmp=0;
int i;
if (untilbuf)
{
/* 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(p->rfd[0], p->buf[0],
- info->cmp, untilbuf);
+ if ( p->more[0] && ((kctrl->cmp)(untilbuf, p->buf[0]) >= 2) )
+ p->more[0] = rset_forward(p->rfd[0], p->buf[0], untilbuf);
}
if (info->ordered && info->relation == 3 && info->exclusion == 0
&& info->distance == 1)
p->more[0] = 0; /* saves us a goto out of while loop. */
break;
}
- cmp = (*info->cmp) (p->buf[i], p->buf[i-1]);
+ cmp = (*kctrl->cmp) (p->buf[i], p->buf[i-1]);
if (cmp > 1)
{
p->more[i-1] = rset_forward (p->rfd[i-1],
p->buf[i-1],
- info->cmp,
p->buf[i]);
break;
}
else if (cmp == 1)
{
- if ((*info->getseq)(p->buf[i-1]) +1 !=
- (*info->getseq)(p->buf[i]))
+ if ((*kctrl->getseq)(p->buf[i-1]) +1 !=
+ (*kctrl->getseq)(p->buf[i]))
{ /* 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 (p->rfd[i], p->buf[i],
- info->cmp, p->buf[i-1]);
+ p->more[i] = rset_forward (p->rfd[i],
+ p->buf[i], p->buf[i-1]);
break;
}
}
if (i == info->rset_no)
{
- memcpy (buf, p->buf[0], info->key_size);
+ memcpy (buf, p->buf[0], kctrl->key_size);
p->more[0] = rset_read (p->rfd[0], p->buf[0]);
p->hits++;
return 1;
{
while (p->more[0] && p->more[1])
{
- int cmp = (*info->cmp)(p->buf[0], p->buf[1]);
+ int cmp = (*kctrl->cmp)(p->buf[0], p->buf[1]);
if (cmp < -1)
p->more[0] = rset_forward (p->rfd[0],
- p->buf[0], info->cmp, p->buf[0]);
+ p->buf[0], p->buf[0]);
+ /* FIXME - this certainly looks wrong! */
else if (cmp > 1)
p->more[1] = rset_forward (p->rfd[1],
- p->buf[1], info->cmp, p->buf[1]);
+ p->buf[1], p->buf[1]);
else
{
- int seqno[500];
+ zint seqno[500]; /* FIXME - why 500 ?? */
int n = 0;
- seqno[n++] = (*info->getseq)(p->buf[0]);
+ seqno[n++] = (*kctrl->getseq)(p->buf[0]);
while ((p->more[0] = rset_read (p->rfd[0],
p->buf[0])) >= -1 &&
p->more[0] <= -1)
if (n < 500)
- seqno[n++] = (*info->getseq)(p->buf[0]);
+ seqno[n++] = (*kctrl->getseq)(p->buf[0]);
for (i = 0; i<n; i++)
{
- int diff = (*info->getseq)(p->buf[1]) - seqno[i];
+ int diff = (*kctrl->getseq)(p->buf[1]) - seqno[i];
int excl = info->exclusion;
if (!info->ordered && diff < 0)
diff = -diff;
}
if (excl)
{
- memcpy (buf, p->buf[1], info->key_size);
+ memcpy (buf, p->buf[1], kctrl->key_size);
p->more[1] = rset_read ( p->rfd[1], p->buf[1]);
p->hits++;
static int r_read (RSFD rfd, void *buf)
{
- return r_forward(rfd, buf, 0, 0);
+ return r_forward(rfd, buf, 0);
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rstemp.c,v 1.47 2004-08-31 10:43:40 heikki Exp $
+/* $Id: rstemp.c,v 1.48 2004-09-01 15:01:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
#include <stdio.h>
#include <zebrautl.h>
-#include <rstemp.h>
+#include <rset.h>
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
const struct rset_control *rset_kind_temp = &control;
struct rset_temp_info {
- int fd;
- char *fname;
- size_t key_size; /* key size */
+ int fd; /* file descriptor for temp file */
+ char *fname; /* name of temp file */
char *buf_mem; /* window buffer */
size_t buf_size; /* size of window */
size_t pos_end; /* last position in set */
int dirty; /* window is dirty */
zint hits; /* no of hits */
char *temp_path;
- int (*cmp)(const void *p1, const void *p2);
};
struct rset_temp_rfd {
zint cur; /* number of the current hit */
};
-RSET rstemp_create( NMEM nmem, int key_size,
- int (*cmp)(const void *p1, const void *p2),
+RSET rstemp_create( NMEM nmem, const struct key_control *kcontrol,
const char *temp_path)
{
- RSET rnew=rset_create_base(&control, nmem);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol);
struct rset_temp_info *info;
info = (struct rset_temp_info *) nmem_malloc(rnew->nmem, sizeof(*info));
info->fd = -1;
info->fname = NULL;
- info->key_size = key_size;
info->buf_size = 4096;
info->buf_mem = (char *) nmem_malloc (rnew->nmem, info->buf_size);
info->pos_end = 0;
info->pos_buf = 0;
info->dirty = 0;
info->hits = 0;
- info->cmp = cmp;
if (!temp_path)
info->temp_path = NULL;
{
struct rset_temp_info *info = (struct rset_temp_info*) ct->priv;
- xfree (info->buf_mem);
logf (LOG_DEBUG, "r_delete: set size %ld", (long) info->pos_end);
if (info->fname)
{
logf (LOG_DEBUG, "r_delete: unlink %s", info->fname);
unlink (info->fname);
- xfree (info->fname); /* FIXME should be nmem'd, and not freed here */
}
- /*
- if (info->temp_path)
- xfree (info->temp_path);
- xfree (info);
- */ /* nmem'd */
}
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);
+ prfd->buf = nmem_malloc (ct->nmem,ct->keycontrol->key_size);
}
r_rewind (rfd);
return rfd;
logf (LOG_FATAL|LOG_ERRNO, "mkstemp %s", template);
exit (1);
}
- info->fname = (char *) xmalloc (strlen(template)+1);
+ info->fname= nmem_malloc(rfd->rset->nmem,strlen(template)+1);
strcpy (info->fname, template);
#else
char *s = (char*) tempnam (info->temp_path, "zrs");
- info->fname = (char *) xmalloc (strlen(s)+1);
+ info->fname= nmem_malloc(rfd->rset->nmem,strlen(template)+1);
strcpy (info->fname, s);
logf (LOG_DEBUG, "creating tempfile %s", info->fname);
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;
+ size_t nc = mrfd->pos_cur + rfd->rset->keycontrol->key_size;
if (mrfd->pos_cur < info->pos_buf || nc > info->pos_border)
{
r_reread (rfd);
}
memcpy (buf, info->buf_mem + (mrfd->pos_cur - info->pos_buf),
- info->key_size);
+ rfd->rset->keycontrol->key_size);
mrfd->pos_cur = nc;
mrfd->cur++;
return 1;
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;
+ size_t nc = mrfd->pos_cur + rfd->rset->keycontrol->key_size;
if (nc > info->pos_buf + info->buf_size)
{
}
info->dirty = 1;
memcpy (info->buf_mem + (mrfd->pos_cur - info->pos_buf), buf,
- info->key_size);
+ rfd->rset->keycontrol->key_size);
mrfd->pos_cur = nc;
if (nc > info->pos_end)
info->pos_border = info->pos_end = nc;
projects / idzebra-moved-to-github.git / commitdiff