be re-searched if needed.
Fixed memory leak in rsm_or.
+Fixed bug in Sort that caused it NOT to use character mapping as
+it should.
+
Zebra now uses GNU configure to generate Makefile(s).
Added un-optimised support for left and left/right truncation attributes.
<!doctype linuxdoc system>
<!--
- $Id: zebra.sgml,v 1.41 1998-06-11 15:42:21 adam Exp $
+ $Id: zebra.sgml,v 1.42 1998-09-22 10:03:39 adam Exp $
-->
<article>
<title>Zebra Server - Administrators's Guide and Reference
<author><htmlurl url="http://www.indexdata.dk/" name="Index Data">,
<tt><htmlurl url="mailto:info@indexdata.dk" name="info@indexdata.dk"></>
-<date>$Revision: 1.41 $
+<date>$Revision: 1.42 $
<abstract>
The Zebra information server combines a versatile fielded/free-text
search engine with a Z39.50-1995 frontend to provide a powerful and flexible
server system — <tt/gcc/ works fine if your own system doesn't
provide an adequate compiler.
-Unpack the distribution archive. In some cases, you may want to edit
-the top-level <tt/Makefile/, eg. to select a different C compiler, or
-to specify machine-specific libraries in the <bf/ELIBS/ variable.
+Unpack the distribution archive. The <tt>configure</tt> shell script
+attempts to guess correct values for various system-dependent variables
+used during compilation. It uses those values to create a 'Makefile' in
+each directory of Zebra.
-When you are done editing the <tt>Makefile</tt> type:
+To run the configure script type:
<tscreen><verb>
-$ make
+ ./configure
</verb></tscreen>
+The configure script attempts to use C compiler specified by
+the <tt>CC</tt> environment variable. If not set, <tt>cc</tt>
+will be used. The <tt>CFLAGS</tt> environment variable holds
+options to be passed to the C compiler. If you're using a Bourne-shell
+compatible shell you may pass something like this:
+<tscreen><verb>
+ CC=/opt/ccs/bin/cc CFLAGS=-O ./configure
+</verb></tscreen>
+
+When configured build the software by typing:
+<tscreen><verb>
+ make
+</verb></tscreen>
+
+As an option you may type <tt>make depend</tt> to create
+source file dependencies for the package. This is only needed,
+however, if you alter the source.
+
If successful, two executables have been created in the sub-directory
<tt/index/.
<descrip>
/*
- * Copyright (C) 1994-1998, Index Data I/S
+ * Copyright (C) 1994-1998, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: extract.c,v $
- * Revision 1.84 1998-06-11 15:42:22 adam
+ * Revision 1.85 1998-09-22 10:03:41 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.84 1998/06/11 15:42:22 adam
* Changed the way use attributes are specified in the recordId
* specification.
*
sk->next = sortKeys;
sortKeys = sk;
- sk->string = xmalloc (p->length);
- sk->length = p->length;
- memcpy (sk->string, p->string, p->length);
+ sk->string = xmalloc (length);
+ sk->length = length;
+ memcpy (sk->string, string, length);
+
sk->attrSet = p->attrSet;
sk->attrUse = p->attrUse;
}
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zebraapi.c,v $
- * Revision 1.9 1998-09-02 13:53:17 adam
+ * Revision 1.10 1998-09-22 10:03:42 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.9 1998/09/02 13:53:17 adam
* Extra parameter decode added to search routines to implement
* persistent queries.
*
zh->errCode = 0;
zh->errString = NULL;
zh->hits = 0;
- rpn_search (zh, stream, decode, query, num_bases, basenames, setname);
+
+ resultSetAddRPN (zh, stream, decode, query, num_bases, basenames, setname);
+
zebra_register_unlock (zh);
}
zh->errCode = 0;
zh->errString = NULL;
zebra_register_lock (zh);
- resultSetSort (zh, stream, num_input_setnames, input_setnames,
+ resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
output_setname, sort_sequence, sort_status);
zebra_register_unlock (zh);
}
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zrpn.c,v $
- * Revision 1.84 1998-09-18 12:41:00 adam
+ * Revision 1.85 1998-09-22 10:03:43 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.84 1998/09/18 12:41:00 adam
* Fixed bug with numerical relations.
*
* Revision 1.83 1998/09/02 13:53:19 adam
}
static RSET rpn_sort_spec (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
- oid_value attributeSet, ODR stream,
+ oid_value attributeSet, NMEM stream,
Z_SortKeySpecList *sort_sequence,
const char *rank_type)
{
if (!sort_sequence->specs)
{
sort_sequence->num_specs = 10;
- sort_sequence->specs = odr_malloc (stream, sort_sequence->num_specs *
- sizeof(*sort_sequence->specs));
+ sort_sequence->specs = nmem_malloc (stream, sort_sequence->num_specs *
+ sizeof(*sort_sequence->specs));
for (i = 0; i<sort_sequence->num_specs; i++)
sort_sequence->specs[i] = 0;
}
if (!oid_ent_to_oid (&oe, oid))
return 0;
- sks = odr_malloc (stream, sizeof(*sks));
- sks->sortElement = odr_malloc (stream, sizeof(*sks->sortElement));
+ sks = nmem_malloc (stream, sizeof(*sks));
+ sks->sortElement = nmem_malloc (stream, sizeof(*sks->sortElement));
sks->sortElement->which = Z_SortElement_generic;
- sk = sks->sortElement->u.generic = odr_malloc (stream, sizeof(*sk));
+ sk = sks->sortElement->u.generic = nmem_malloc (stream, sizeof(*sk));
sk->which = Z_SortKey_sortAttributes;
- sk->u.sortAttributes = odr_malloc (stream, sizeof(*sk->u.sortAttributes));
+ sk->u.sortAttributes = nmem_malloc (stream, sizeof(*sk->u.sortAttributes));
sk->u.sortAttributes->id = oid;
sk->u.sortAttributes->list =
- odr_malloc (stream, sizeof(*sk->u.sortAttributes->list));
+ nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list));
sk->u.sortAttributes->list->num_attributes = 1;
sk->u.sortAttributes->list->attributes =
- odr_malloc (stream, sizeof(*sk->u.sortAttributes->list->attributes));
+ nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list->attributes));
ae = *sk->u.sortAttributes->list->attributes =
- odr_malloc (stream, sizeof(**sk->u.sortAttributes->list->attributes));
+ nmem_malloc (stream, sizeof(**sk->u.sortAttributes->list->attributes));
ae->attributeSet = 0;
- ae->attributeType = odr_malloc (stream, sizeof(*ae->attributeType));
+ ae->attributeType = nmem_malloc (stream, sizeof(*ae->attributeType));
*ae->attributeType = 1;
ae->which = Z_AttributeValue_numeric;
- ae->value.numeric = odr_malloc (stream, sizeof(*ae->value.numeric));
+ ae->value.numeric = nmem_malloc (stream, sizeof(*ae->value.numeric));
*ae->value.numeric = use_value;
- sks->sortRelation = odr_malloc (stream, sizeof(*sks->sortRelation));
+ sks->sortRelation = nmem_malloc (stream, sizeof(*sks->sortRelation));
if (sort_relation_value == 1)
*sks->sortRelation = Z_SortRelation_ascending;
else if (sort_relation_value == 2)
else
*sks->sortRelation = Z_SortRelation_ascending;
- sks->caseSensitivity = odr_malloc (stream, sizeof(*sks->caseSensitivity));
+ sks->caseSensitivity = nmem_malloc (stream, sizeof(*sks->caseSensitivity));
*sks->caseSensitivity = 0;
sks->missingValueAction = 0;
static RSET rpn_search_APT (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
- oid_value attributeSet, ODR stream,
+ oid_value attributeSet, NMEM stream,
Z_SortKeySpecList *sort_sequence,
int num_bases, char **basenames)
{
}
static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
- oid_value attributeSet, ODR stream,
+ oid_value attributeSet, NMEM stream,
Z_SortKeySpecList *sort_sequence,
int num_bases, char **basenames)
{
#ifdef ASN_COMPILED
if (*zop->u.prox->u.known != Z_ProxUnit_word)
{
- char *val = odr_malloc (stream, 16);
+ char *val = nmem_malloc (stream, 16);
zh->errCode = 132;
zh->errString = val;
sprintf (val, "%d", *zop->u.prox->u.known);
#else
if (*zop->u.prox->proximityUnitCode != Z_ProxUnit_word)
{
- char *val = odr_malloc (stream, 16);
+ char *val = nmem_malloc (stream, 16);
zh->errCode = 132;
zh->errString = val;
sprintf (val, "%d", *zop->u.prox->proximityUnitCode);
return r;
}
-void rpn_search (ZebraHandle zh, ODR stream, ODR decode,
+
+RSET rpn_search (ZebraHandle zh, NMEM nmem,
Z_RPNQuery *rpn, int num_bases, char **basenames,
- const char *setname)
+ const char *setname,
+ ZebraSet sset)
{
RSET rset;
oident *attrset;
zh->errString = NULL;
zh->hits = 0;
- sort_sequence = odr_malloc (stream, sizeof(*sort_sequence));
+ sort_sequence = nmem_malloc (nmem, sizeof(*sort_sequence));
sort_sequence->num_specs = 10;
- sort_sequence->specs = odr_malloc (stream, sort_sequence->num_specs *
+ sort_sequence->specs = nmem_malloc (nmem, sort_sequence->num_specs *
sizeof(*sort_sequence->specs));
for (i = 0; i<sort_sequence->num_specs; i++)
sort_sequence->specs[i] = 0;
attrset = oid_getentbyoid (rpn->attributeSetId);
attributeSet = attrset->value;
- rset = rpn_search_structure (zh, rpn->RPNStructure, attributeSet, stream,
- sort_sequence,
- num_bases, basenames);
+ rset = rpn_search_structure (zh, rpn->RPNStructure, attributeSet,
+ nmem, sort_sequence, num_bases, basenames);
if (!rset)
- return;
+ return 0;
- resultSetAdd (zh, setname, 1, rset, &zh->hits);
if (zh->errCode)
logf (LOG_DEBUG, "search error: %d", zh->errCode);
-
+
for (i = 0; sort_sequence->specs[i]; i++)
;
sort_sequence->num_specs = i;
- if (i)
- resultSetSort (zh, stream, 1, &setname, setname, sort_sequence,
- &sort_status);
+ if (!i)
+ resultSetRank (zh, sset, rset);
+ else
+ {
+ logf (LOG_DEBUG, "resultSetSortSingle in rpn_search");
+ resultSetSortSingle (zh, nmem, sset, rset,
+ sort_sequence, &sort_status);
+ if (zh->errCode)
+ {
+ logf (LOG_DEBUG, "resultSetSortSingle status = %d", zh->errCode);
+ }
+ }
+ return rset;
}
struct scan_info_entry {
return 0;
}
-static void scan_term_untrans (ZebraHandle zh, ODR stream, int reg_type,
+static void scan_term_untrans (ZebraHandle zh, NMEM stream, int reg_type,
char **dst, const char *src)
{
char term_dst[1024];
term_untrans (zh, reg_type, term_dst, src);
- *dst = odr_malloc (stream, strlen(term_dst)+1);
+ *dst = nmem_malloc (stream, strlen(term_dst)+1);
strcpy (*dst, term_dst);
}
}
if (j0 == -1)
break;
- scan_term_untrans (zh, stream, reg_id,
+ scan_term_untrans (zh, stream->mem, reg_id,
&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),
if (j0 == -1)
break;
- scan_term_untrans (zh, stream, reg_id,
+ scan_term_untrans (zh, stream->mem, reg_id,
&glist[before-1-i].term, mterm);
rset = rset_trunc
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zserver.h,v $
- * Revision 1.37 1998-09-02 13:53:22 adam
+ * Revision 1.38 1998-09-22 10:03:44 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.37 1998/09/02 13:53:22 adam
* Extra parameter decode added to search routines to implement
* persistent queries.
*
void (*add)(void *set_handle, int seqno, int term_index);
};
-void rpn_search (ZebraHandle zh, ODR stream, ODR decode,
+RSET rpn_search (ZebraHandle zh, NMEM mem,
Z_RPNQuery *rpn, int num_bases, char **basenames,
- const char *setname);
+ const char *setname, ZebraSet sset);
void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
RSET rset_trunc (ZebraHandle zh, ISAM_P *isam_p, int no,
const char *term, int length_term, const char *flags);
-ZebraSet resultSetAdd (ZebraHandle zh, const char *name,
- int ov, RSET rset, int *hits);
+ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov);
ZebraSet resultSetGet (ZebraHandle zh, const char *name);
+ZebraSet resultSetAddRPN (ZebraHandle zh, ODR stream, ODR decode, Z_RPNQuery *rpn, int num_bases, char **basenames,
+ const char *setname);
RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId);
void resultSetDestroy (ZebraHandle zh);
int num, int *positions);
void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num);
-void resultSetSort (ZebraHandle zh, ODR stream,
+void resultSetSort (ZebraHandle zh, NMEM nmem,
int num_input_setnames, const char **input_setnames,
const char *output_setname,
Z_SortKeySpecList *sort_sequence, int *sort_status);
+void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
+ ZebraSet sset, RSET rset,
+ Z_SortKeySpecList *sort_sequence, int *sort_status);
+void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset);
void zebra_sort (ZebraHandle zh, ODR stream,
int num_input_setnames, const char **input_setnames,
/*
- * Copyright (C) 1994-1998, Index Data I/S
+ * Copyright (C) 1994-1998, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zsets.c,v $
- * Revision 1.17 1998-06-23 15:33:36 adam
+ * Revision 1.18 1998-09-22 10:03:45 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.17 1998/06/23 15:33:36 adam
* Added feature to specify sort criteria in query (type 7 specifies
* sort flags).
*
struct zebra_set {
char *name;
RSET rset;
- int size;
+ NMEM nmem;
+ int hits;
+ int num_bases;
+ char **basenames;
+ Z_RPNQuery *rpn;
struct zset_sort_info *sort_info;
struct zebra_set *next;
};
struct zset_sort_entry **entries;
};
-void resultSetRank (ZebraHandle zh, struct zset_sort_info *si,
- RSET rset, int *hits);
+ZebraSet resultSetAddRPN (ZebraHandle zh, ODR stream, ODR decode,
+ Z_RPNQuery *rpn, int num_bases, char **basenames,
+ const char *setname)
+{
+ ZebraSet zebraSet;
+
+ zlog_rpn (rpn);
+
+ zh->errCode = 0;
+ zh->errString = NULL;
+ zh->hits = 0;
+
+ zebraSet = resultSetAdd (zh, setname, 1);
+ if (!zebraSet)
+ return 0;
+ zebraSet->rpn = 0;
+ zebraSet->num_bases = num_bases;
+ zebraSet->basenames = basenames;
+ zebraSet->nmem = odr_extract_mem (decode);
+
+ zebraSet->rset = rpn_search (zh, stream->mem, rpn,
+ zebraSet->num_bases,
+ zebraSet->basenames, zebraSet->name,
+ zebraSet);
+ zh->hits = zebraSet->hits;
+ if (zebraSet->rset)
+ zebraSet->rpn = rpn;
+ return zebraSet;
+}
-ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov,
- RSET rset, int *hits)
+ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
{
ZebraSet s;
int i;
for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
- {
- logf (LOG_DEBUG, "updating result set %s", name);
- if (!ov)
- return NULL;
- rset_delete (s->rset);
- s->rset = rset;
- resultSetRank (zh, s->sort_info, rset, hits);
- return s;
- }
- logf (LOG_DEBUG, "adding result set %s", name);
- s = xmalloc (sizeof(*s));
- s->next = zh->sets;
- zh->sets = s;
- s->name = xmalloc (strlen(name)+1);
- strcpy (s->name, name);
- s->rset = rset;
-
- s->sort_info = xmalloc (sizeof(*s->sort_info));
- s->sort_info->max_entries = 1000;
- s->sort_info->entries = xmalloc (sizeof(*s->sort_info->entries) *
- s->sort_info->max_entries);
- s->sort_info->all_entries = xmalloc (sizeof(*s->sort_info->all_entries) *
- s->sort_info->max_entries);
- for (i = 0; i < s->sort_info->max_entries; i++)
- s->sort_info->entries[i] = s->sort_info->all_entries + i;
- resultSetRank (zh, s->sort_info, rset, hits);
+ break;
+ if (s)
+ {
+ logf (LOG_DEBUG, "updating result set %s", name);
+ if (!ov)
+ return NULL;
+ if (s->rset)
+ rset_delete (s->rset);
+ if (s->nmem)
+ nmem_destroy (s->nmem);
+ }
+ else
+ {
+ logf (LOG_DEBUG, "adding result set %s", name);
+ s = xmalloc (sizeof(*s));
+ s->next = zh->sets;
+ zh->sets = s;
+ s->name = xmalloc (strlen(name)+1);
+ strcpy (s->name, name);
+
+ s->sort_info = xmalloc (sizeof(*s->sort_info));
+ s->sort_info->max_entries = 1000;
+ s->sort_info->entries =
+ xmalloc (sizeof(*s->sort_info->entries) *
+ s->sort_info->max_entries);
+ s->sort_info->all_entries =
+ xmalloc (sizeof(*s->sort_info->all_entries) *
+ s->sort_info->max_entries);
+ for (i = 0; i < s->sort_info->max_entries; i++)
+ s->sort_info->entries[i] = s->sort_info->all_entries + i;
+ }
+ s->rset = 0;
+ s->nmem = 0;
return s;
}
for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
+ {
+ if (!s->rset && s->rpn)
+ {
+ NMEM nmem = nmem_create ();
+ s->rset =
+ rpn_search (zh, nmem, s->rpn, s->num_bases,
+ s->basenames, s->name, s);
+ nmem_destroy (nmem);
+
+ }
return s;
+ }
return NULL;
}
xfree (s->sort_info->entries);
xfree (s->sort_info);
+ if (s->nmem)
+ nmem_destroy (s->nmem);
rset_delete (s->rset);
xfree (s->name);
xfree (s);
new_entry->score = score;
}
-void resultSetSort (ZebraHandle zh, ODR stream,
+void resultSetSort (ZebraHandle zh, NMEM nmem,
int num_input_setnames, const char **input_setnames,
const char *output_setname,
Z_SortKeySpecList *sort_sequence, int *sort_status)
{
ZebraSet sset;
RSET rset;
- int i, psysno = 0;
- struct it_key key;
- struct sortKey sort_criteria[3];
- int num_criteria;
- int term_index;
- RSFD rfd;
if (num_input_setnames == 0)
{
if (!sset)
{
zh->errCode = 30;
- zh->errString = nmem_strdup (stream->mem, input_setnames[0]);
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
return;
}
if (!(rset = sset->rset))
{
zh->errCode = 30;
- zh->errString = nmem_strdup (stream->mem, input_setnames[0]);
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
return;
}
+ if (strcmp (output_setname, input_setnames[0]))
+ {
+ rset = rset_dup (rset);
+ sset = resultSetAdd (zh, output_setname, 1);
+ sset->rset = rset;
+ }
+ resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
+}
+
+void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
+ ZebraSet sset, RSET rset,
+ Z_SortKeySpecList *sort_sequence, int *sort_status)
+{
+ int i, psysno = 0;
+ struct it_key key;
+ struct sortKey sort_criteria[3];
+ int num_criteria;
+ int term_index;
+ RSFD rfd;
+
+ logf (LOG_DEBUG, "resultSetSortSingle start");
+ sset->sort_info->num_entries = 0;
+
+ sset->hits = 0;
num_criteria = sort_sequence->num_specs;
if (num_criteria > 3)
num_criteria = 3;
break;
}
}
- if (strcmp (output_setname, input_setnames[0]))
- {
- int hits;
- rset = rset_dup (rset);
- sset = resultSetAdd (zh, output_setname, 1, rset, &hits);
- }
- sset->sort_info->num_entries = 0;
-
rfd = rset_open (rset, RSETF_READ);
while (rset_read (rset, rfd, &key, &term_index))
{
if (key.sysno != psysno)
{
+ (sset->hits)++;
psysno = key.sysno;
resultSetInsertSort (zh, sset,
sort_criteria, num_criteria, psysno);
zh->errCode = 0;
*sort_status = Z_SortStatus_success;
-
- return;
+ logf (LOG_DEBUG, "resultSetSortSingle end");
}
RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
return NULL;
}
-void resultSetRank (ZebraHandle zh, struct zset_sort_info *sort_info,
- RSET rset, int *hits)
+void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
{
int kno = 0;
struct it_key key;
int term_index, i;
ZebraRankClass rank_class;
struct rank_control *rc;
+ struct zset_sort_info *sort_info;
+ sort_info = zebraSet->sort_info;
sort_info->num_entries = 0;
- *hits = 0;
+ zebraSet->hits = 0;
rfd = rset_open (rset, RSETF_READ);
logf (LOG_DEBUG, "resultSetRank");
int score;
void *handle =
(*rc->begin) (zh, rank_class->class_handle, rset);
- (*hits)++;
+ (zebraSet->hits)++;
do
{
kno++;
score = (*rc->calc) (handle, psysno);
resultSetInsertRank (zh, sort_info, psysno, score, 'A');
- (*hits)++;
+ (zebraSet->hits)++;
psysno = key.sysno;
}
(*rc->add) (handle, key.seqno, term_index);
(*rc->end) (zh, handle);
}
rset_close (rset, rfd);
- logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, *hits);
+ logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
}
ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
/*
- * Copyright (C) 1994-1998, Index Data I/S
+ * Copyright (C) 1994-1998, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: rsm_or.c,v $
- * Revision 1.6 1998-03-05 08:36:28 adam
+ * Revision 1.7 1998-09-22 10:03:46 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.6 1998/03/05 08:36:28 adam
* New result set model.
*
* Revision 1.5 1997/12/18 10:54:25 adam
ct->no_rset_terms = 1;
ct->rset_terms = xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = rset_term_dup (r_parms->rset_term);
+ ct->rset_terms[0] = r_parms->rset_term;
return info;
}
# Zebra indexes as referred to from the *.abs-files.
-# $Id: default.idx,v 1.4 1998-02-10 12:03:06 adam Exp $
+# $Id: default.idx,v 1.5 1998-09-22 10:03:47 adam Exp $
#
# Traditional word index
index w
# Sort register (no mapping at all)
sort s
completeness 1
-charmap @
+charmap string.chr
projects / idzebra-moved-to-github.git / commitdiff